{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configuration for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install pyvirtualdisplay\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(600, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02. PPO\n",
    "\n",
    "- PPO: [J. Schulman et al., \"Proximal Policy Optimization Algorithms.\" arXiv preprint arXiv:1707.06347, 2017.](https://arxiv.org/abs/1707.06347.pdf)\n",
    "- TRPO: [Schulman, John, et al. \"Trust region policy optimization.\" International conference on machine learning. 2015.](http://proceedings.mlr.press/v37/schulman15.pdf)\n",
    "\n",
    "There are two kinds of algorithms of PPO: PPO-Penalty and PPO-Clip. Here, we'll implement PPO-clip version.\n",
    "\n",
    "TRPO computes the gradients with a complex second-order method. On the other hand, PPO tries to solve the problem with a first-order methods that keep new policies close to old. To simplify the surrogate objective, let $r(\\theta)$ denote the probability ratio\n",
    "\n",
    "$$ L^{CPI}(\\theta) = \\hat {\\mathbb{E}}_t \\left [ {\\pi_\\theta(a_t|s_t) \\over \\pi_{\\theta_{old}}(a_t|s_t)} \\hat A_t\\right] = \\hat {\\mathbb{E}}_t \\left [ r_t(\\theta) \\hat A_t \\right ].$$\n",
    "\n",
    "The objective is penalized further away from $r_t(\\theta)$\n",
    "\n",
    "$$ L^{CLIP}(\\theta)=\\hat {\\mathbb{E}}_t \\left [ \\min(r_t(\\theta) \\hat A_t, \\text{clip}(r_t(\\theta), 1-\\epsilon, 1+\\epsilon)\\hat A_t) \\right ] $$\n",
    "\n",
    "If the advantage is positive, the objective will increase. As a result, the action becomes more likely. If advantage is negative, the objective will decrease. AS a result, the action becomes less likely."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "from collections import deque\n",
    "from typing import Deque, Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output\n",
    "from torch.distributions import Normal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.backends.cudnn.enabled:\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "\n",
    "seed = 777\n",
    "torch.manual_seed(seed)\n",
    "np.random.seed(seed)\n",
    "random.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "We will use two separated networks for actor and critic respectively. The actor network consists of two fully connected hidden layer with ReLU branched out two fully connected output layers for mean and standard deviation of Gaussian distribution. Pendulum-v0 has only one action which has a range from -2 to 2. In order to fit the range, the actor outputs the mean value with tanh. The result will be scaled in ActionNormalizer class. On the one hand, the critic network has three fully connected layers as two hidden layers (ReLU) and an output layer. One thing to note is that we initialize the last layers' weights and biases as uniformly distributed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_layer_uniform(layer: nn.Linear, init_w: float = 3e-3) -> nn.Linear:\n",
    "    \"\"\"Init uniform parameters on the single layer.\"\"\"\n",
    "    layer.weight.data.uniform_(-init_w, init_w)\n",
    "    layer.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    return layer\n",
    "\n",
    "class Actor(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        out_dim: int, \n",
    "        log_std_min: int = -20,\n",
    "        log_std_max: int = 0,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Actor, self).__init__()\n",
    "\n",
    "        self.log_std_min = log_std_min\n",
    "        self.log_std_max = log_std_max\n",
    "        self.hidden = nn.Linear(in_dim, 32)\n",
    "\n",
    "        self.mu_layer = nn.Linear(32, out_dim)\n",
    "        self.mu_layer = init_layer_uniform(self.mu_layer)\n",
    "\n",
    "        self.log_std_layer = nn.Linear(32, out_dim)\n",
    "        self.log_std_layer = init_layer_uniform(self.log_std_layer)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden(state))\n",
    "        \n",
    "        mu = torch.tanh(self.mu_layer(x))\n",
    "        log_std = torch.tanh(self.log_std_layer(x))\n",
    "        log_std = self.log_std_min + 0.5 * (\n",
    "            self.log_std_max - self.log_std_min\n",
    "        ) * (log_std + 1)\n",
    "        std = torch.exp(log_std)\n",
    "\n",
    "        dist = Normal(mu, std)\n",
    "        action = dist.sample()\n",
    "\n",
    "        return action, dist\n",
    "\n",
    "\n",
    "class Critic(nn.Module):\n",
    "    def __init__(self, in_dim: int):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Critic, self).__init__()\n",
    "\n",
    "        self.hidden = nn.Linear(in_dim, 64)\n",
    "        self.out = nn.Linear(64, 1)\n",
    "        self.out = init_layer_uniform(self.out)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden(state))\n",
    "        value = self.out(x)\n",
    "\n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GAE\n",
    "\n",
    "*GAE* help to reduce variance while maintaining a proper level of bias. By adjusting parameters $\\lambda \\in [0, 1]$ and $\\gamma \\in [0, 1]$. Please see [the paper](https://arxiv.org/pdf/1506.02438) for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_gae(\n",
    "    next_value: list, \n",
    "    rewards: list, \n",
    "    masks: list, \n",
    "    values: list, \n",
    "    gamma: float, \n",
    "    tau: float\n",
    ") -> List:\n",
    "    \"\"\"Compute gae.\"\"\"\n",
    "    values = values + [next_value]\n",
    "    gae = 0\n",
    "    returns: Deque[float] = deque()\n",
    "\n",
    "    for step in reversed(range(len(rewards))):\n",
    "        delta = (\n",
    "            rewards[step]\n",
    "            + gamma * values[step + 1] * masks[step]\n",
    "            - values[step]\n",
    "        )\n",
    "        gae = delta + gamma * tau * masks[step] * gae\n",
    "        returns.appendleft(gae + values[step])\n",
    "\n",
    "    return list(returns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PPO Agent\n",
    "Here is a summary of PPOAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "|---               |---                                                   |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|_plot             | plot the training progresses.                        |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PPO updates the model several times(`epoch`) using the stacked memory. By `ppo_iter` function, It yield the samples of stacked memory by interacting a environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ppo_iter(\n",
    "    epoch: int,\n",
    "    mini_batch_size: int,\n",
    "    states: torch.Tensor,\n",
    "    actions: torch.Tensor,\n",
    "    values: torch.Tensor,\n",
    "    log_probs: torch.Tensor,\n",
    "    returns: torch.Tensor,\n",
    "    advantages: torch.Tensor,\n",
    "):\n",
    "    \"\"\"Yield mini-batches.\"\"\"\n",
    "    batch_size = states.size(0)\n",
    "    for _ in range(epoch):\n",
    "        for _ in range(batch_size // mini_batch_size):\n",
    "            rand_ids = np.random.choice(batch_size, mini_batch_size)\n",
    "            yield states[rand_ids, :], actions[rand_ids], values[\n",
    "                rand_ids\n",
    "            ], log_probs[rand_ids], returns[rand_ids], advantages[rand_ids]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PPOAgent:\n",
    "    \"\"\"PPO Agent.\n",
    "    Attributes:\n",
    "        env (gym.Env): Gym env for training\n",
    "        gamma (float): discount factor\n",
    "        tau (float): lambda of generalized advantage estimation (GAE)\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): amount of clipping surrogate objective\n",
    "        epoch (int): the number of update\n",
    "        rollout_len (int): the number of rollout\n",
    "        entropy_weight (float): rate of weighting entropy into the loss function\n",
    "        actor (nn.Module): target actor model to select actions\n",
    "        critic (nn.Module): critic model to predict state values\n",
    "        transition (list): temporory storage for the recent transition\n",
    "        device (torch.device): cpu / gpu\n",
    "        total_step (int): total step numbers\n",
    "        is_test (bool): flag to show the current mode (train / test)        \n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        env: gym.Env,\n",
    "        batch_size: int,\n",
    "        gamma: float,\n",
    "        tau: float,\n",
    "        epsilon: float,\n",
    "        epoch: int,\n",
    "        rollout_len: int,\n",
    "        entropy_weight: float,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        self.env = env\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = epsilon\n",
    "        self.epoch = epoch\n",
    "        self.rollout_len = rollout_len\n",
    "        self.entropy_weight = entropy_weight\n",
    "\n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.shape[0]\n",
    "        self.actor = Actor(obs_dim, action_dim).to(self.device)\n",
    "        self.critic = Critic(obs_dim).to(self.device)\n",
    "\n",
    "        # optimizer\n",
    "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=0.001)\n",
    "        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=0.005)\n",
    "\n",
    "        # memory for training\n",
    "        self.states: List[torch.Tensor] = []\n",
    "        self.actions: List[torch.Tensor] = []\n",
    "        self.rewards: List[torch.Tensor] = []\n",
    "        self.values: List[torch.Tensor] = []\n",
    "        self.masks: List[torch.Tensor] = []\n",
    "        self.log_probs: List[torch.Tensor] = []\n",
    "\n",
    "        # total steps count\n",
    "        self.total_step = 1\n",
    "\n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        state = torch.FloatTensor(state).to(self.device)\n",
    "        action, dist = self.actor(state)\n",
    "        selected_action = dist.mean if self.is_test else action\n",
    "\n",
    "        if not self.is_test:\n",
    "            value = self.critic(state)\n",
    "            self.states.append(state)\n",
    "            self.actions.append(selected_action)\n",
    "            self.values.append(value)\n",
    "            self.log_probs.append(dist.log_prob(selected_action))\n",
    "\n",
    "        return selected_action.cpu().detach().numpy()\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "        next_state = np.reshape(next_state, (1, -1)).astype(np.float64)\n",
    "        reward = np.reshape(reward, (1, -1)).astype(np.float64)\n",
    "        done = np.reshape(done, (1, -1))\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.rewards.append(torch.FloatTensor(reward).to(self.device))\n",
    "            self.masks.append(torch.FloatTensor(1 - done).to(self.device))\n",
    "\n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(\n",
    "        self, next_state: np.ndarray\n",
    "    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "\n",
    "        next_state = torch.FloatTensor(next_state).to(device)\n",
    "        next_value = self.critic(next_state)\n",
    "\n",
    "        returns = compute_gae(\n",
    "            next_value,\n",
    "            self.rewards,\n",
    "            self.masks,\n",
    "            self.values,\n",
    "            self.gamma,\n",
    "            self.tau,\n",
    "        )\n",
    "\n",
    "        states = torch.cat(self.states).view(-1, 3)\n",
    "        actions = torch.cat(self.actions)\n",
    "        returns = torch.cat(returns).detach()\n",
    "        values = torch.cat(self.values).detach()\n",
    "        log_probs = torch.cat(self.log_probs).detach()\n",
    "        advantages = returns - values\n",
    "\n",
    "        actor_losses, critic_losses = [], []\n",
    "\n",
    "        for state, action, old_value, old_log_prob, return_, adv in ppo_iter(\n",
    "            epoch=self.epoch,\n",
    "            mini_batch_size=self.batch_size,\n",
    "            states=states,\n",
    "            actions=actions,\n",
    "            values=values,\n",
    "            log_probs=log_probs,\n",
    "            returns=returns,\n",
    "            advantages=advantages,\n",
    "        ):\n",
    "            # calculate ratios\n",
    "            _, dist = self.actor(state)\n",
    "            log_prob = dist.log_prob(action)\n",
    "            ratio = (log_prob - old_log_prob).exp()\n",
    "\n",
    "            # actor_loss\n",
    "            surr_loss = ratio * adv\n",
    "            clipped_surr_loss = (\n",
    "                torch.clamp(ratio, 1.0 - self.epsilon, 1.0 + self.epsilon) * adv\n",
    "            )\n",
    "\n",
    "            # entropy\n",
    "            entropy = dist.entropy().mean()\n",
    "\n",
    "            actor_loss = (\n",
    "                -torch.min(surr_loss, clipped_surr_loss).mean()\n",
    "                - entropy * self.entropy_weight\n",
    "            )\n",
    "\n",
    "            # critic_loss\n",
    "            value = self.critic(state)\n",
    "            #clipped_value = old_value + (value - old_value).clamp(-0.5, 0.5)\n",
    "            critic_loss = (return_ - value).pow(2).mean()\n",
    "        \n",
    "            # train critic\n",
    "            self.critic_optimizer.zero_grad()\n",
    "            critic_loss.backward(retain_graph=True)\n",
    "            self.critic_optimizer.step()\n",
    "\n",
    "            # train actor\n",
    "            self.actor_optimizer.zero_grad()\n",
    "            actor_loss.backward()\n",
    "            self.actor_optimizer.step()\n",
    "\n",
    "            actor_losses.append(actor_loss.item())\n",
    "            critic_losses.append(critic_loss.item())\n",
    "\n",
    "        self.states, self.actions, self.rewards = [], [], []\n",
    "        self.values, self.masks, self.log_probs = [], [], []\n",
    "\n",
    "        actor_loss = sum(actor_losses) / len(actor_losses)\n",
    "        critic_loss = sum(critic_losses) / len(critic_losses)\n",
    "\n",
    "        return actor_loss, critic_loss\n",
    "\n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "\n",
    "        state = self.env.reset()\n",
    "        state = np.expand_dims(state, axis=0)\n",
    "\n",
    "        actor_losses, critic_losses = [], []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        while self.total_step <= num_frames + 1:\n",
    "            for _ in range(self.rollout_len):\n",
    "                self.total_step += 1\n",
    "                action = self.select_action(state)\n",
    "                next_state, reward, done = self.step(action)\n",
    "\n",
    "                state = next_state\n",
    "                score += reward[0][0]\n",
    "\n",
    "                # if episode ends\n",
    "                if done[0][0]:\n",
    "                    state = env.reset()\n",
    "                    state = np.expand_dims(state, axis=0)\n",
    "                    scores.append(score)\n",
    "                    score = 0\n",
    "\n",
    "                    self._plot(\n",
    "                        self.total_step, scores, actor_losses, critic_losses\n",
    "                    )\n",
    "\n",
    "            actor_loss, critic_loss = self.update_model(next_state)\n",
    "            actor_losses.append(actor_loss)\n",
    "            critic_losses.append(critic_loss)\n",
    "\n",
    "        # termination\n",
    "        self.env.close()\n",
    "\n",
    "    def test(self):\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "\n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "\n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "\n",
    "        return frames\n",
    "\n",
    "    def _plot(\n",
    "        self,\n",
    "        frame_idx: int,\n",
    "        scores: List[float],\n",
    "        actor_losses: List[float],\n",
    "        critic_losses: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "\n",
    "        def subplot(loc: int, title: str, values: List[float]):\n",
    "            plt.subplot(loc)\n",
    "            plt.title(title)\n",
    "            plt.plot(values)\n",
    "\n",
    "        subplot_params = [\n",
    "            (131, f\"frame {frame_idx}. score: {np.mean(scores[-10:])}\", scores),\n",
    "            (132, \"actor_loss\", actor_losses),\n",
    "            (133, \"critic_loss\", critic_losses),\n",
    "        ]\n",
    "\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(30, 5))\n",
    "        for loc, title, values in subplot_params:\n",
    "            subplot(loc, title, values)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "*ActionNormalizer* is an action wrapper class to normalize the action values ranged in (-1. 1). Thanks to this class, we can make the agent simply select action values within the zero centered range (-1, 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActionNormalizer(gym.ActionWrapper):\n",
    "    \"\"\"Rescale and relocate the actions.\"\"\"\n",
    "\n",
    "    def action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (-1, 1) to (low, high).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = action * scale_factor + reloc_factor\n",
    "        action = np.clip(action, low, high)\n",
    "\n",
    "        return action\n",
    "\n",
    "    def reverse_action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (low, high) to (-1, 1).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = (action - reloc_factor) / scale_factor\n",
    "        action = np.clip(action, -1.0, 1.0)\n",
    "\n",
    "        return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see [the code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/pendulum.py) and [configurations](https://github.com/openai/gym/blob/cedecb35e3428985fd4efad738befeb75b9077f1/gym/envs/__init__.py#L81) of Pendulum-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# environment\n",
    "env_id = \"Pendulum-v0\"\n",
    "env = gym.make(env_id)\n",
    "env = ActionNormalizer(env)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 100000\n",
    "\n",
    "agent = PPOAgent(\n",
    "    env,\n",
    "    gamma = 0.9,\n",
    "    tau = 0.8,\n",
    "    batch_size = 64,\n",
    "    epsilon = 0.2,\n",
    "    epoch = 64,\n",
    "    rollout_len = 2048,\n",
    "    entropy_weight = 0.005\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABsQAAAE/CAYAAADxMaZGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzsnXmcHVWZ/p/3Lr13Z4HsBMKeBFBEBAVxQVBQFNdRdETcGLff6OioODPu+zLuCKIgg8oiLqCAsoZ9CYEQlmyEGEjS2bfe771V9f7+OHXqnqpbt+/tTne6E57v59Of9K3l1KlT1enqes7zvKKqIIQQQgghhBBCCCGEEEIIIWRfJTPWHSCEEEIIIYQQQgghhBBCCCFkNKEgRgghhBBCCCGEEEIIIYQQQvZpKIgRQgghhBBCCCGEEEIIIYSQfRoKYoQQQgghhBBCCCGEEEIIIWSfhoIYIYQQQgghhBBCCCGEEEII2aehIEYIIYQQQgghhBBCCCGEEEL2aSiIkTFFRI4UkcdEpFtE/n2s+0MIIYQQQgghhBBCCCGEkH0PCmJkrPkcgAWq2q6qPx3rziQRkUtEZIWIBCJyXsr6/xCRjSLSJSKXiUijs26OiCwQkT4RWS4ipznr3icij4T7rROR74lIzlk/WUT+IiK9IvKsiLzbWTdDRP4qIp0ioiIyZ9QGYBxQ63zDsbpGRLaJyFYR+b2IdDjrvy4iT4iIJyJfqXGsv4tIj/NVFJEnnPXHisg9IrIrvG5fTOz/IRFZFe77DxGZ6axrFJGLRWSTiGwXkb+JyCxn/SdEZJGIFETk8kS788N1O8Kv20RkfmKb40Tk7vDYm0Tkkynn98pwDL/hLKt1L/YkvnwR+Vm4rkFE/igia8J2X5U43mdF5MlQ8P6niHw2sX7QayMi/y/crys8/5dXXDRCCCGE1CT8XX1a7S0JIYQQQsYvIvIeEbllkPWniMiK3Wj/PBG5d7j7E0LGPxTEyFhzEICnqq0Ukewe7EsaSwB8DMCjyRUi8joAFwB4Dcx5HALgq84mVwFYDGA/AP8N4I8iMiVc1wLgUwD2B3Bi2MZ/OvteCKAIYBqA9wC4SESOCtcFAP4B4G27f3ojiyukjCC1zvcbACYBOBjAoTBj9hVn/SoY4fXGWgdS1TNVtc1+AbgfwLXOJlcCuBvAZACvBPAxEXkTAIRi0LcAnB2u/yfMPWD5JICXAXgBgJkAdgD4mbO+MzyXy1K61gng7WG7+wP4K4Cr7UoR2R9mjH4Jc78dBiD2gCgieQA/AfBQou1B78XEeEwH0J8Yk3sB/CuAjSn9FgDnwlyfMwB8QkTe5ayvem1E5EQA3wnPewKASwH8ZRz8n0AIIYSMChStCCGEEEIGR1V/r6qvtZ/DybmHOevvUdUjx6Z3hJC9AQpiZMwQkTsAvBrAz0PnyREicrmIXCQiN4lIL4BXi8gbRGRx6BJZ6zpJxLiwVETeH67bISIfEZGXiMjjIrJTRH6eOO4HRGRZuO3NInJQtT6q6oWqejuAgZTV7wNwqao+pao7AHwdwHnhMY4AcByAL6tqv6r+CcATCEUdVb0o/CVdVNX1AH4P4ORw39Zwuy+qao+q3gsjgLw33HeTqv4CwMNDHHKISJOI/E6Mm2qniDwsItPCdZNF5DdinFg7ROQ6Z78Ph86n7WLcWq7zSUXk4yLyNICnw2VzReTWcPsVIvIvQ+2rpY7zPRjAdarapaq7APwFwFHO/v+nqn8H0D2U44pxop0C4Apn8RwAv1dVX1WfgRGD7LHOAnBteD8UYe6HV4jIoU4/bw7PZwDANYl+/llVrwOwLWUMdqrqGlVVGJHJhxG9LJ8O2/69qhZUtVtVlyWa+QyMSLY80XbVezGFtwHYDOCecN+iqv44vEf9lH5/T1UfVVVPVVcAuN5tu8a1mQPgKVV9JDzvK2BEu6lV+kYIIYQ8bxmlSUmEEEIIIeMGPu8QQkYCCmJkzFDVU2FerH8idKCsDFe9G8A3AbTDCA69MC6TiQDeAOCjIvLmRHMnAjgcwDsB/BjGkXUajODwLyLySgAQkbMB/BeAtwKYEh7/KgyPo2AcZJYlAKaJyH7hutWq2p1YfxTSeQXKTrkjAHjOeNTadyi8D8ZtMxvGSfQRGMcPAPwWxi10FIzo8CMAEJFTAXwbwL8AmAHgWTjupJA3w1yD+aGgdyuMm2oqgHcB+IWEEX8i8m4ReXwEzsVyIYCzRGSSiEyCEW3+PgLtngvgHlVd4yz7MYBzRSQvIkfCOL5uc9ZLyvdHh/9eCuBkEZkpIi0wzr8h9VNEdsKIsz+DcaNZXgpgu4jcLyKbxcQxHujsdxCADwD4Wh2Hce/FJO8DcEUoUA0JEREYgbGqIzTB3wFkReTE0BX2AQCPId2JRgghhIwrROQCEXkmjA1eKiJvcdZ9OJycZdcdJyK/BXAggL+FE8U+F277JhF5KpzIdKeIzHPaWSMinw+fq3rrfUkkJsb5x+EkqM7w+8Zw3f4ickN4vO1ioqIz4brPi8j6sN8rROQ1IzhkhBBCCHkeIyKzReTPIrIlnMT9czHxhfeJyI9EZBuAr4gTaSgid4e7Lwmfn94pIq8SkXWDtTvEfp0UTibfFf57krPuPBFZLeUyEe8Jlx8mIneF+2wVkWt2f4QIISMFBTEyHrleVe9T1UBVB1T1TlV9Ivz8OIyA9crEPl8Pt70FRkC7SlU3h46XewC8KNzuIwC+rarLVNWDERWOlUFcYoPQBmCX89l+356yzq5vTzYiIh8AcDyAHzjtdtWz7zAoIYzUC11Oj6hql4jMAHAmgI+o6g5VLanqXeE+7wFwWej0KQD4AoCXSbyW17dVdbuq9sM4pdao6m9CZ9BiAH8C8A4AUNUrVfUFI3AulkcBNMA4q7bBOJV+MQLtngvg8sSyG2Ai/PphnFaXqqp1rv0DRnx9gYg0A/gSAIURGQHjnlsLYD3M9Z2H+gSqCFWdCCNofgImjtNyAIxY9UmYl2nJuMafInQcDtZ+yr3orjsI5ufu/4bSZ4evwPzO+U2d23fD3Df3AigA+DKA84cjxhFCCCFjwDMwE0EmwERq/05MXdR3wPxOPBdAB4A3Adimqu8F8ByAN4YTxb4nJnHgKpho4ykAboIRzBqc45wDM2FsYvhsWw//DTOZ5lgALwRwAoD/Cdd9BsC68HjTYCaSaTgR6BMAXqKq7QBeB2DNkEaEEEIIISSFcBLsDTATsOcAmIXyROwTAayGeS75prufqr4i/PaF4fNTTHiq0W49/ZoMU+LhpzDv0n4I4EYR2S+cDP5TAGeGz0YnwUziBUxi0C0w5SMOQLxcBiFkjKEgRsYja90PoUNkQTibYxeMqLV/Yp9Nzvf9KZ/bwu8PAvCTcNbrTgDbYZw8s4bRzx6YFxkW+313yjq7PhYNFzrdvg3zC3RrlXZT9x0mvwVwM4CrwxnB3xNTW2o2gO1h9GOSmTAPDwCAUFTZhviYudfsIAAn2jEOx/k9MPWnBkVM8dOe8KteJ9EfAKyEEQw7YF5A/a7Ofav14+Uw/f2js2wyjOj1NQBNMGP2OhH5GACo6m0wos2fYF4QrYG5ZnZm0oUAGmEeoloB/BnDcLKpai+AiwFcISI2PrAfwF9U9eEwjvGrAE4SkQki8kYA7ckHw5RzTrsXXd4L4F5V/edQ+ywin4B58feGUFSthw8CeD+MY7EBpk7ZDeLEdRJCCCHjFVW9VlU7wwld18BMjDkBwIcAfC/8na2qukpVn63SzDsB3Kiqt6pqCWbCSjPMCxfLT1V1bTgpqV7eA+Br4eSxLTDPDe8N15VgEgEOCidI3RNORvFhnmPmi0g+jHJ+ZgjHJIQQQgipxgkw754+q6q94YT3e8N1nar6s3DC9VCed2q1Ww9vAPC0qv42PP5VMJOj3xiuDwAcLSLNqrpBVe17rBLMu7GZwzgmIWSUoSBGxiNJB8iVMDW0ZqvqBBgxQCr2qo+1AP5NVSc6X82qev8w2noKZlat5YUANqnqtnDdISLSnlgfiTwicgaAX8HMBH7C2W4lgJyIHF5t3+ESvtj4qqrOh3mZchaMULEWwGQRmZiyWyfML3Lb71YYUWe927Tz/VoAdyXGuE1VP1pH/+4Jt21T1XojIo8F8Mvw4aYH5v54fZ37VuN9AP6ccFQdAsBX1SvCB6F1MDOLomOpqTl3uKpOgxHGcgCedPp5eeikK8DMEDpBRJLibj1kYJxnVpR8HPFr4H7/GgDHi8hGEdkI83LtUyJyvd1gkHvR5VwMwx0Wus4uAPCacMzq5VgAN6jqyvBl4j8AbED8JSAhhBAyLhGRc0XkMWdy0NEwE7pmw0zeqYfkpKQA5jmr2qSkeom1G35vJ5x8H8AqALeEEUAXhMdeBeNU+wqAzSJyNSepEEIIIWSEmA3g2Spu9+E869TTbj0kn5kQfp4VTlZ+J8yk/Q0icqOIzA23+RzMe8uFYqKvPzDM4xNCRgEKYmRvoB3GvTQgIifA1BgbLhcD+IKIHAUAoYPmHdU2FpEGEWmC+UWWF5EmW0cBwBUAPigi80Mh6X8QRuypqf/1GIAvh/u8BcALYEQSW5fr9wDepqoL3WOGv1T/DOBrItIqIicDOBvG3WX71QQzSxcAGsPPNRGRV4vIMaFtvAtm1kqgqhtg3Eq/EFOLKy8i1np+FYD3i8ixYupLfAvAQxqvreVyA4AjROS9YTt5EXmJODUvhkqN830YwIdEpDmMKjwfRiCy++bD7TMwQmNTeP7VjtUMUy/t8sSqlWa1vFtEMiIyHebh53HbRxE5WgwHArgEwE8c193DMPXHJoSuvI/BzHTaGu6fC/uZhamd1SRhLRAROV1EXiQiWRHpgLHp7wCwLGz7NwDeEl6jPIAvwri5doXfHwEjMB0LIy7/CsZ9Nei96IzJSTAv365NWedej4aw3xKuew/M/XK6qq5O2Xewa/MwgDeIyCHhmJ4enseTyXYIIYSQ8YSYmOFfwUQM7hdGHj8J8zy5FsChVXZNTgpLTkoSmBc71SYl1UusXZi45U4AUNVuVf2Mqh4CE+f4aQlrhYWx1y8P91UA3x3GsQkhhBBCkqwFcKCk10PdnbIJg7VbD8lnJsA8N60HAFW9WVVPh3HXL4d5/oOqblTVD6vqTAD/BvOu7bBh9oEQMsJQECN7Ax+DEYe6Yeoy/WG4DanqX2D+eL9aRLpgXk6cOcgut8DE0Z0EI3D0A3hF2NY/AHwPwAKYmg/PwkTmWd4FU49pB4DvAHh7GEsDGJFiAoCbnIhANz7vYzCROJthBKmPOtZrhP2w7qXl4WcAgIhcLCIXVzkfGwPYBSOm3IWy0PZeGIFseXjcT4XneVvY3z/BOHQODc8tFVXtBvDacJtOABthxtwWa3+P1B+HaKl6vgA+AJMFvQ7moeQQGIeX5Vfh9ufA1MzoD881imhMHOvNAHbCXFf3vLoAvBXAf8Bc08dg7p9vhJs0wbgZewAsBPAAzLhZ/hPAAExk0hYYZ9lbnPX/E/btAph4wH6U63lMhLkPdsHMKj8UwBlhPCJU9Q6YGh83wly7wxAKx+GLrY32K2y3V1W3h23XuheBsmMuLbZzRdjmLJg4zn6UHxi/AeMmfNhp2703q14bGMH5agB3wtyvP4Vxdy5P6QMhhBAynmiFeXmzBQBE5P0wDjEA+DWA/xSRF4cTPg6Tci3bTTDPMZY/wEwOeU044eUzMHU1h5Ns4HIVgP8RkSlinOpfQhg3LSJnhX0SmOcOH0AgIkeKyKnh5KgBmN/ZwW72gxBCCCEEMO9QNgD4TjgxvCmcHF4PyeenkWoXMPVbjwgnRudE5J0A5sOUc5gmImeLSVEqwLwLCgBARN4hIgeEbeyAeS7kcxMh4wQxkfCEEEIIIYQQQkYCEfkmgI/CvPy4AsCLAfxWVX8tIh+BmWAzC6bm6HtVdbGInA0TqdwB4Buq+gMxKQPfDLd9DMDH7CQpEVkD4EPh5KVa/Ym2Dd3Z3wNgUxKuBfC5MI3hPwB8EsAUmBc4v1TVr4vIC2DEvHkwE6juB3C+qnbuzjgRQgghhABAmLTzUwCnwAhIVwJ4FOb55eXOdue5y8Lnqi/DTCo/H2aS8O9U9YBq7arqvw/Sj2T7LwfwE5iJx6sAfFJV7xWRGTCTeI8N27XPaUtF5HswNVsnwAh231XVS3Z3jAghIwMFMUIIIYQQQgghhBBCCCGEELJPw8hEQgghhBBCCCGEEEIIIYQQsk9DQYwQQgghhBBC9mJE5ECnXmfy68Cx7h8hhBBCyHhBRC6u8sx0ce29CSF7O4xMJIQQQgghhBBCCCGEEEIIIfs0dIgRQgghhBBCCCGEEEIIIYSQfZrcWHdgd9l///11zpw5Y90NQgghhAzCI488slVVp4x1PwifnQghhJC9AT47jR/47EQIIYSMf+p9dtrrBbE5c+Zg0aJFY90NQgghhAyCiDw71n0gBj47EUIIIeMfPjuNH/jsRAghhIx/6n12YmQiIYQQQgghhBBCCCGEEEII2aehIEYIIYQQQgghhBBCCCGEEEL2aSiIEUIIIYQQQgghhBBCCCGEkH0aCmKEEEIIIYQQQgghhBBCCCFkn4aCGCGEEEIIIYQQQgghhBBCCNmnoSBGCCGEEEIIIYQQQgghhBBC9mkoiBFCCCGEEEIIIYQQQgghhJB9mnEniInIGSKyQkRWicgFY90fQgghhBBCCCGEEEIIIYQQsnczrgQxEckCuBDAmQDmAzhHROaPba8IIYQQQgghhBBCCCGEEELI3sy4EsQAnABglaquVtUigKsBnD3GfSJkj7FuRx/6iz4AwA8U63b0DbutIFDcv2orVHWkujcsblu6CQuWb0YQKHb2FbFqc3fFNss3dkX93NpTwOotPbH1qop7n659LkUvwJPrd9Xdt7Xb+/DnR9ehc2c/ADNmacdZ2tmFbT2F2LIdvUU81WmO9cyWHmzpLkR9feTZ7dF2m7oGBr2Om7oGUsfEZf3O/oox8QPFA89sq3GG1Xl6Uzc8PwAA7Owr4vF1O2Prl23owg2Pd2Kg5Nfd5s6+ItZuL5/rio3dQ9o/yfKNXdjeWwRgxnVXfym2vnNnP3b1ldJ2BWDGzV6XpZ1d0fn6geLhNdujMV25qRtdA9XbsSxZuxMlP0DJD2LnWY2tPQUs39hVsdwPfzbroegF6B4oobfgRf83jCRBYO7XtH4SMhQeeXYH/vTIurHuBiGEEEIIeR7zwDPb0FPwxrobhBBCxjHjTRCbBWCt83lduCyGiJwvIotEZNGWLVv2WOcIGW3e9PP7cNl9/wQA3PLURpz6g7sGfeE/GAvXbMe7f/0Qlm4Yuxfdz23rw4euWIT3X/4wnli/C2f+5B6c9sO7Y9vcvXILzvjxPbh2kXmResp3F+DU/70rts21j6zDv176EP786PpBj/el65/EWT+7NxK4avHZPy7Bp/+wBD++bSUA4N5VW/Gvl1aO2Xm/WYgLFzwTW/are1bjvZcuBAC85n/vwsnfuQMA8NA/t+NtFz0QCQwnfut2vPy7C6r24cRv3V4xJklO/s4dFWNy8V3P4JxfPYj76hRWXNZu78PpP7ob37ppOQDg8vvX4J2/fDASAgdKPs78yT34xJWLcduyTXW3e9oP78Yp3zPn2lf08Lof341PXr14yP2znHfZw/jlXWbc739mG47/xq3Y3D0QrT/pO3fgNT+8E4B5GT/nghvxjCMc/vtVi/GNG5dic/cA3vCze3DrUnMuF925Cu+4+AF87PePAgBe+6O7cc4lDw7al81dA3jzL+7DTU9swJeufwqnfG8BdvYVB93nojufwQcvX1Sx/BcLVuHdv36ormt34YJVePOF9+GoL9+Ml3779prbV+MHN6/Ax698tGL59UvW420XPYAzf3LPmIvnz2dE5DIR2SwiTzrLrhGRx8KvNSLyWJV914jIE+F2lTfcHuIvi9fhK397ivcRIYQQQggZE5Z2duGcXz2Iax5eW3tjQgghz1vGmyBWF6p6iaoer6rHT5kyZay7Q8iIEASK7b3FyBGzo6+Eoh+gtzi82U09A2a/vlFwldRLv+MO6iv62LBroGKbpzqNcGSFjP4UR9H6HUbgeq6GK+eB1cYxVfCCuvrnjrX72f4LGGfStt4itvfGHWJdA6XYzLNi6D7qCl1M3QOjOyvNOpSe3TZ0F6F1Q93/jBFkuvo99Jd8DJTMObj3zI4hCLJbHRddyTcvxe9aOfxJC71FL+rLs9v6UPIV23riItTW8PPflnQCMAKrZWdfETv6Suge8KCKyGFmXWPudbb3YTW29Rahao5354rNYf8G/9nqLXjoTnGerd7aCwDYmPLzkGTt9j5s6jL9TTrkhsLj63dVuAABYHuvaVN1bP+vILgcwBnuAlV9p6oeq6rHAvgTgD8Psv+rw22PH8U+Dsrc6R3oHvCwvs4JCYQQQgghhIwkVy58FgDqSvMghBDy/GW8CWLrAcx2Ph8QLiNkn8cKKsVQzAnCWfbBMGfbe0E5Hm6scI9d7Tz6QsGvtTFXtZ2MCADUdB7YSLlcRurqnxUNe0Nhq7sQ/wwYcc0PFD2FuFhQ9IIogs/FC8/Z80d33JsbsgDK4zcU8lnzX390z/nm3KzAV3QExZ5hCHuqiiCwbrP6xMn0hgCFhn0zwk0pZcyB8j3i3nMlX1H0/OhalMJ19rxzGanbzWLHpmfAi46RlcHvMz/Q1J8/u1s9P9vdBS92PYZLz0AJvYVKwSt2rRktMmao6t0AtqetExEB8C8ArtqjnRoi82Z0AACWbRg8ApYQQgghhJCRpq/o4brFZpIkJ2gRQggZjPEmiD0M4HAROVhEGgC8C8Bfx7hPhOwRkoKYfVU+3PQpK8wEYyiIuS/8vSr9sC/pW0KBJw2rb/l1CmL1iohWAHPFDvO5LBx0R8vi7pyiFyDQyvGNBLFg90WMwWjOm/EaTl0pKyoVQrGq5Jk+96YIYr3DEEn6S37Na1UPgSrs8NprU00cymXNTeLeZ54foOgF0flaAdM6CL0qglUa0T1SKEX3l2LwfX3V1Ps+Gwm8dRx3wIv+b9gdegpeqrhJQWyv4BQAm1T16SrrFcAtIvKIiJy/B/sV48jp7QCA5WMY00sIIYQQQsYPFy5YhU/tRoT+UPjbkk70FDxMaW+su4QCIYSQ5yfjShBTVQ/AJwDcDGAZgD+o6lNj2ytC9gz2xbR9+a276xDz7f4j0Llh4va9mjBnHU4tDYM4xEJFrNa52LjFekQOVY3Enp6E6NXjxNz1Rq6xhEMsvE6lhPBlRZdqAuDuUPDKfbACYl9KxGQtkvea/TdyiPnlNocjkrguqt0h0LJo1J0i1rlkM5UOsaKvKPpBtMz+a+McvSBdsEqj1xFP/TpdgEGV9q2brZ6f7ZESqayw5t5DQOJaj3LMJxk252Bwd9jLVfU4AGcC+LiIvCJto9Guv9rWmMNB+7Vg+UY6xAghhBBCnu+s3tKDH926Etc91okNu0ZfoLpy4VocNrUNr50/jYIYIYSQQRlXghgAqOpNqnqEqh6qqt8c6/4QsqeIRArrEAvflQ9XV7CumJFw6gwXV5yoJpDYOkyDO8RCAaHGYHgJ4WMw+kt+2X2UEMbc2lA9KTGKQPk6lRKiiBuZWG8cX724gkVzKCAOzyEWRgcm7jl7rm4NtuHUQusueCMiCAZaHsPIIRbe18l7IZsamWgcYtatVz5vM2aeI5bVwh6/e6B8brUELetAS94HmfA3bz0/myMliHVXE3bpEBvXiEgOwFsBXFNtG1VdH/67GcBfAJxQZbtRr786d3o7ltEhRgghhBDyvOdbNy2LJrbetmzzqB7rqc5dWLJ2J959woGYNakZO/pKwyotQAgh5PnBuBPECHm+knTt7G4NMfuif7xEJlZ7+d8fPqhmB6n7FZa8qnss6hIaBqwzLRsJAVY0cEWg5DqLFY2SgpR1DflBEBOWRgJXsGjKZ1KPXw9JIcz2My2WcDiRib0FD/4I1FBTLV/zZH2zpDPP3j/pkYkafXbbGIpDrMdxiNmfqVr72r4ntxOpz/EIDE+QTOK6IasJuyN1LDLinAZguaquS1spIq0i0m6/B/BaAE/uwf7FmDu9A//c1jus/5cIIYQQQsi+wb1Pb8VtyzbjU6cdjoP3b8VtSzeN6vGuWvgcGnIZvPW4WZg1sRkA0LlzYFSPSQghZO+Fghgh44RkDTH7sny4LqPSENxSo4V76GrCnHWsDCZ2ZSL3T33HrRVlB5QFrukTmtBX9OEHWnaIOaJB2jKgfJ0qBLGgLLa4AlbadawW/1eNeHvm3+FEJkY1xEKnlL33eouVgthwIxNHooaaQqPztP1IutsAc2/lMpUuwpKvKHhBdD/Yn4miE2s51BpivQUvElxr7ZuMarRY7been+3hCJJJXDdkUvRy65PRITZ2iMhVAB4AcKSIrBORD4ar3oVEXKKIzBSRm8KP0wDcKyJLACwEcKOq/mNP9TvJvBkdUAVWbmJsIiGEEELI8xHPD/D1G5Zi9uRmfODkg3HavKl44Jlto/a3Rl/Rw3WLO/GGY2ZgYksDZkaCGGMTCSGEpENBjJBxQmVk4u7VAPMTTrOxIF7PKV0gsVEGg3VzKDWX6t3OCl3TO5oAGDHIdQFZrEhkRTNLUkSyeJEbSWMRh2luoqGKHW579v7oH0YURCEhupYSkYn23FoashXOuHroLoxcDbFkrKWteeVGVfYWvSiOw46zqqkf5kYm+kHCIeYHdQt3vY57sJrQlcTe8slrn603AtQPorp4u4N73yTv14IXRHGlbu08smdR1XNUdYaq5lX1AFW9NFx+nqpenNi2U1VfH36/WlVfGH4dNdZR0/NmtAMAYxMJIYQQQp6nXLNoLVZs6sZ/nTkPTfksTp8/HUU/wN0rR76GLQD8bUknegoe3n3igQBAQYwQQkhNKIgRMk6IHGJ+sobY8ISFeuscjSbuC/+u/vSX7bZe12D9lCE4aoDaUXZAWWCxgljPQLog1l1FTLCiSl+dDrE0N9hQZ8m521sxZjiCSVKctJ+TkYmTWhqG5VDqGfBGpHZdWg2xklfpEOst+JFDzI/Er/J2rkgJAEW/LDYna8BVw7036hfEysKbi41MrHXoZL2v4dIPsgI9AAAgAElEQVSd4ni0FL0Ak1sbzDo6xMhuMntSC1obsli+kQ4xQgghhJDnG10DJfzwlpU44eDJOOPo6QCA4w6ciEktedw6SrGJVy5ci8OmtuH4gyYBAKa1NyIjFMQIIYRUh4IYIeOECocYbA2w4bVXimpZ7X7fhourF+yqIoj1hS/hk9qCK6YFitRtqh63jg2t0DVtQugQK3iRWBBz1FQRE8qCWMIhZutL+cHoCmI2MnEYtXpKib7YvtlztZ/3a2uoEFAGI581Qk9v0YvFVg6njp2qiUu0e9pzL4Q3dCkW9VdCLiw0Z8ff3v8FxwWWFrdYqFNQ7AnFqZ6CF92HtYRXv8p21vFYS+DtLoyMY6snpSaepeAFaGvMoSGbic6RkOGSyQiOnN6OpXSIEUIIIYQ877jwjlXY3lfEF98wP5oEmMtmcOrcabhj+eaKiYK7y1Odu7Bk7U68+4QDY8eb3tGE9awhRgghpAoUxAgZJyQFsbIINDynTeSUGcvIROfYO/vKL/ddIaCaQ8wVEbw64h9dt85QHGIzQkGsu+BFThrXCRaLT3S+t4JM0sUTuZGCeGRiWmSk2141ccRd7rrVrMiUrGFWD25fVDW657qjWELzeXJrw5BEu8ZcNuqnez2GU+cs6ZAsO8Rs/TNXEPMRanFlZ5hTk68UXRO7rNyfQp113GycoHtN/RpqdVDFSWZriFWLEY2OOUKOLbedZJtFL0BjLoO2phx6RkiAI89v5s7owPINXcOuf0kIIYQQQvY+nt3Wi8vu+yfeftwBOOaACbF1p8+fil39JTy8ZseIHvOqhc+hIZfBW4+bFVs+Y2IzHWKEEEKqQkGMkHFCJIglIhOH+07RigBj+VIyFpk44Api5W2sKJTspyt+1RP/6IpY9dSvssed1pHiEKsiIHSnOL76S8kaYuWYvFoOMbe9al2O1cqKbW+WD8sh5ggxA6WgXA8t4RCb3GIEsaE6vHoKXkyUHE7sot07UHMf9RTjYl3MITZQee292DnG6465QlS9gpgVPt3zqjXB0Y/cavENbb0zG/9YjaG48waju4rjETDXuiGXQVtjbsSOR57fzJvRga4BDxt2cVYuIYQQQsYeEcmKyGIRuSH8fLCIPCQiq0TkGhFpGOs+7gt8+6blyGcz+OzrjqxYd8rhU9CQy4xobGJf0cN1iztx1jEzMLElfglnTmxG5y4KYoQQQtKhIEbIOMF1tABlwWP4DrH66hyNJm7f3cjENLEreZpxh1jt+Ej3RX8955ysIbazrxTV44pFzFURE+z1qqwhVnaIuYJXmvDitudVObliLBrQjUzcjRpiTl+6CyUnMtGPHdPWlqrX4WXb6Uk4xLqHIbTYe0RV0Vfyo/ujlHBSAmFdr3B9WYRyHGrhNbKOLleIGqjz3LpTRL1q18xS7WcwiFxsgx877ZjDoVpNPNMHRxBjDTEyAsyb3g4AWMbYREIIIYSMDz4JYJnz+bsAfqSqhwHYAeCDY9KrfYgHntmGfzy1ER971aGYGv597dLamMPJh+6HW5dtHLEJu39b0omegodzTjywYt3MiU3YsGtgWNH9hBBC9n0oiBEyTkg6xCzDFcRKNjJxDB8C3WPHBbHKba0TKG3fSMgYRIBIcwkNRveAh4ZsJhJ9NnUZN0MuIzGhqrfoIYwjjx3DClx9ychERxDrreEQ64lFIKb30633NRqRiT0DXvS5O+EQmxSOTT3OIVWNOc1csWg4DrGyIIbU6MlSQigMnHFPrrfuQW+3HGJeFHVoqXWfWdHSFefcPqbdEy4j5djqcdyZqQ6xrIlMHI5wSUiSI0NBbPnG7jHuCSGEEEKe74jIAQDeAODX4WcBcCqAP4ab/B+AN49N7/YN/EDx9RuWYtbEZnzolEOqbnf6/OlYu70fKzf1jMhxr1y4FodPbcPxB02qWDdrYjOKXoBtvcUROdZg/HVJJ97083spvhFCyF4EBTFCxgkVNcSsc2qY7UWuqrGMTIw5xCrj/gpOLafAEVSAuDhWqkNA6B6yQ6yEtqYc2hpzAICNYbzX1PZG9Bb9cl2tAQ/7tTaG+1QKXG5UI1Aed7+OGmJpji+LjZis6hALF++uQ6yn4DkOsbggtp8VxKrUltreW8TdK7fAD+LXrrvgxQS+wZxHqooFyzdXXDO3hph7/KST0vbbjl+QIohZ0dK9j1obTL2zNIeY5wfY2Rf/46m34GFqe3y2Y2WfFas290THruYQs2JhUihLMtI1xCa15FNriDXkMminQ4yMEO1Necye3EyHGCGEEELGAz8G8DkA9o+D/QDsVFX74LsOwKy0HUl9/OmRdVi6oQufP3MumvLZqtu9Zt5UAMBty3Y/NvGpzl1YsnYnzjnhQIhIxfqZE5oBYI/UEbt92SY8vm4XtveNvvhGCCFkZKAgRsge4Ns3LcPl9/1z0G0Kvq1J5eOntz8dCTy1IgX+/sQGfPzKRyuWl1/GD72/X79hKe59eit29hXxqasX447lm/DxKx/Fz25/Gl++/slou/6ij8/9cUmFeFDuQ/n7rv7KGmKuYKSqMbdOPDIxLoI81bkL96/aGq3f2VfEW39xf+q+gBHezr1sIV7yzdvw3La+6NhtjTm0WkEsdIhNaTfi1xH/83d89W9PobfgYVqHWfaNG5dhW08h5oZKOrTKYkd6DbGC5+NHt65Ef9GPIgoBwPcVa7f3obfg4fF1O/GCr9yCcy9biK/fsDTaJuYo07LY4tZnA4BrHn4Oyzd24cNXLMIVD6yBquKWpzbi6oXPxfoCxAUx237SIXbupQvx+T8+js9euwSAicS4cMEqvPTbt+PcyxbiojtXxcSdnoG4Q6ya0PLXJZ343UPP4f2XP4wLF6wy4xeKUa5DzHUube8p4k+PrMP9z2yLte9XOMScGmaRQ6x8HzU3mOvu3nN+oLht6SZ84c9P4Niv3Yp/PLkR5162EG+/6H5s6y1G94G7PQBc8KfHcem9/8R5v3kYp/3wLpz6v3fik1cvjtr+/s0rcPaF92HB8s2x/QZzp23uHqjqrLt16aaKdUvW7sQjz24HAFxy9zNYu93c5xt29ePnC1YhnxVMajU14fqLftQHE5mYRWsoiH3jhqX41d2rq/aLkHqYO72DghghhBBCxhQROQvAZlV9ZJj7ny8ii0Rk0ZYtW0a4d/sGPQUP37t5BY47cCLe+IIZg247raMJL5w9EbeMQB2xqxY+h4ZcBm89Ll3LnDlxzwliSzvNM+9G1s8lhJC9htxYd4CQ5wMLVmzGnP1acd7JB1fdxnWI/fDWldHyWmanRc/uwG0pD5XWpTIch9jvH3oWGTHiznWPdeK6xzoBADdiAwDgq2cfDQBYvrELf1i0DmccPR2nzp1W0Y577D7HSaWoFAQCjQs1aXXGrAj1hp/eCwBY8503AACeDUWutH0BYP2Ofty90vwRs2pLNw7crwV9RR/N+SwachnksxJFOh46pQ1L1u3C1PZG3PD4BuzX2oBZE5vxVGcXdvWXsGDFFpx97MxI1EvWECs5DjHXAWfP7fcPPoef3P40shmJOZ98VbzlF/fh3JfNwTGzJgBA1GfLQMJRZ3nzz+/DHf/5KgBGAPn8n56I1t26dBNOnTsVf1i0Fmu39+NdJxxY4Z6y42qFq6IfQAR40eyJOGHOZKzZ1otrFq0FAHz/HS/Ev1+9GFu6C3jxQZPQ1V/Cz+5YhdcdNb3cZsmPuaL6iunCzn9c8ximhgLk6i0mOuP7t6zAL+9ajbcdd0B0nq6gdu0j63DtI+ti7fQWPDSHsxH9QRxiXqCRmNncYOaDFByH2KX3rsa3bloefb78/n/iwdXboxiO+TM7sGTdrmi9vS/vXLEFT2/uwSPP7sCZR0/H35/ciLXb+9HeZH7F2lmQNz2xAa+eOzW6R6o5Hu9YvgkfuHwRjjtwYsW6zd0D+PAVi/Ddtx2Dd76knJd/9oX3AQCWfOm1+NZNy/HbB5/FPZ87FX9+dD0GSgFeccQU7Owroqfg4ZXfX4CPv/owvO+kOVFkYmM+g96Ch9uXb8bR4f1HyHCZN6MDty/bhIGSP+hMYUIIIYSQUeRkAG8SkdcDaALQAeAnACaKSC50iR0AYH3azqp6CYBLAOD4449nHl4Kv1iwClt7Cvj1+45PdWolOX3eVPzglpXY3DWQWmusHvqKHq5b3ImzjpmBiS0NqdvMCgWx9aMsiA2UfKze2gvA/J0G8O8oQgjZG6BDjJA9QKC1ow9LVaxctbKo/UCRpnlZYWA4gphqWNOrxr62a9XqX7n7FxPil9tHu607BnGH2OACgt32i2fNr9g3eRzrNir5JioOADIiUdtnvXAGlnzptXjdUdPh+QFKfoCmfBZ3f/bV0X6xuL6E2OM7cXjuuNhzs8Kb5wfocRxiXmAyzrf3FqP+njp3aqztYsLNlMsI3vvSg/Dc9rIg2FuojAAseAFKfnl83XYGvLJ4Zc/FiiRTO5rwh4+8DHd/7tXR7DvPDzBQ8vHKI6bgmvNfigvOnIuCF0R/CNj93WtQ8irvoyBQ+OGXOX/z7+auAgBg8dodZjutXUur5AdRZGKaIOY6xKwY1ZriEHtmc/kcADOWxx80CX/86El4/CuvxQdfHs/Ej8at4GFLt+n3afOm4SfvOjYaB5cBLx6lWO1n/vFQdHv0uZ0V6+xYpF1noCw22/7YWnlXfOAEtDXmsLWngM3dheieKTiRid0DHrpD5yQhu8O86e0IFFi5iXXECCGEEDI2qOoXVPUAVZ0D4F0A7lDV9wBYAODt4WbvA3D9GHVxr2bt9j78+t5/4q0vmoVjZ1dO5Evj9PlmEuVtyzYP+7h/W9KJnoKHc048sOo2Hc05tDZk0blzdF1bKzd1R3/bbdxVGNVjEUIIGTkoiBGyBwhUa0YfVhN7ajnE/EAr6k8BcafSUNFQDKsVt2jPqZpw5h67kOL+cgWBCoeYK4jVqCFmj9MYClxJEdEdH9cFZQWxbEaivmQzGUxoySOXFXi+wgsUuaygOaw55QUa60dfQpgo1xALYuNiz9+6sRrz2YpIRVWz3p7vYVPbYm274+WrIpMxMXjW+QRUq4mlsTpfRSdO0PY/mxH0DHhRdKUdGwBoymdx9Ewz26234CMIFIdNbUMum4m2i9VL8+IOsbT6afYc7VZJkai8f9khls2kzzo04mN8fzcy0br4PGcM7PV078u+xNj1Fj3ks+b8OprymNCcj633w3HvLZYFsdbGbNTPZCSivTa17ufGXNlR05CN/5q2NePSxtRte6BUrgvX0pgN+5aL/lDri8RPH425DNoacyh4AXb1FyNnGyHDZe6MDgDA8g0UxAghhBAy7vg8gE+LyCqYmmKXjnF/9kq+84/lyAjw2TOOrHufI6a14cDJLbtVR+zKhWtx+NS2KMUjDRHBzInNox6Z6EaEb+piZCIhhOwtUBAjZA+gilQXl0vy5bh9919LSPMcl018eVJYqJ9ANXTwDK6IRQ6xKodwl7uOIQ2bdfvm1uVKrotqPyVEACuC2HO14sxgDjG3TpYVG7IikYCSDaMechmBFyg8X5HLZJALL4jnB7F+uCKKqkbH9gKNnX8x4c5qyGZidaCsWFL0ykJahyNM5DISu0dUTV/ztl/hwbpT3FSl0OmW5hCzYtPE5jy8wIhhRT+IxEVLW9iX7kIpJibaMbTt5LOCQtIhliqIBdGYmW3igpYVFgMttz2pJZ9sJtrHHq4YCWLONSqWXYH23K1DzBUQk3W5egteTBhMCkV+oBgomWNboaq1MRfdK0kiQazK/Wxxx35yazwGxApdtcTh6ByKXnSu7Y05bOs1gph1J9praa9vyVc6xMhuc9DkFjTns1i2kXXECCGEEDL2qOqdqnpW+P1qVT1BVQ9T1XeoKq09Q2TFxm7c+PgG/NsrDsWMCc117yciOG3eNNy7amvVesmD8VTnLixZuxPnnHBgzYjGmROb0blrdAWxpZ1daG3IYr/WhjAykRBCyN4ABTFC9gCBas3IxOTL8ZbwJXYtPcuKQknhLHLgDCPtPFAj5tRyiFnhpppoVy3uMUiIIHaZ+5LfFVTsS/6kCGCj8Go5xFxdzz54Fx0XVDZbFpsy4f+KuWwGXhDACwLks4Jc1gpi8X72O5GJgZaFHs+PuwLtPrauWGM+E3NV9RfLQoc9H9eR1NaUizm7/ECREdN3dwy6B8p1ySyl0HVWdFxqtuZWJDaFwktPwYuJhdHxQ5Gke8BDyddofeQQC9tpa8yF5+BcS7/yPki6pPwgLoT5zn1tx2lSSkZ8LmOcfNYFaNuLC2JWiCqPQZpDrKs/PnZ9BT9yiAHm/nLFLi+I1zcDzM9tNpP+q7UQiln23KtFJjbmBxPEysJpGsk2ewseWh2HWFT7zvk5sA4xCwUxsrtkMoIjp7fHZs0SQgghhJB9g+seW49cRvC+k+YMed/T509D0Qtwz9Nbam+c4KqFz6Exl4ni/AdjzzjEujFvRgemT2jCxl0UxAghZG+BghghewAjMA0tMrEpFCxq7ZesnWSxLpS0OMVaaHjcWvvavlUT7artn4zJs22kxSoCQKmKIGbFCC8hiCUdYp4jznSH+7ixgFmRSJC0DrF8xrjGPF+RzUgkjFgXlcWt5VRyalQZh5hGfYoEsVAUEaf/gKnlZduw49LhCGKtDTkUvfKx/MBEJuZD8cUKIUmBxvbFC7TswvICtIaihxUIrfDSawWxpEMs3H5HbxFAWQiz42LbaW/Ko+gHMTE1zQnl+7ZuWSJGMHHfWodYUz6DloZsRTstDVnjEBskMrHXuU/settWwXGI7UoIYr1FL+bWEpHISQUY4TU5s7G1MRuJp0n6Ew6xZKSixRXdJrXGXXFWECt46TXEkg7BvqIfXWu3771FD17orGvIZmLutzZGJpIRYN6MDizf2F3T5UwIIYQQQvYegkDx18c6ccrh+1dM3quHl8yZhAnNedy6dGh1xPqKHq5b3Ik3HDMDE1MmSiaZNbEJW3uKqSUFRgJVxbINXZg3owPTOpqwqYtGQ0II2VugIEbIHiAIaju1ki/H7UvxmoJYKAQkxaek06ZeVDWqIVbN4VXeGIP2sdqxI4dYEBfAYg4xR9CoJiBYMcKKK7b2UnIs3P5FkYl+2QWVceIIbf0n6/IpegHy2Uy03HNi94ByHB8Qj6+0YoMVNq2YVXTOpafgRe32F8vOn1SHWGOuwlGXzUi0f9khlh6Z6EY9Fv0AbaFryAqEk1sSDrGEIGZFlW2hIGaFosY6HGLpkYnx+zMZlWiXB6roLnhoa8zH3Fpuv0rOuKdHJlrRLYjuoZY0h1jCXReoiYCMHa+hLBalOcRaG+qITKzhEHOvc3tjPubWqxWZmBT1egrlyETX+dVb8KOxashloutrjklBjOw+82a0Y2dfiS8HCCGEEEL2IR59bgfW7+zH2cfWdmmlkctmcOrcqbhj+abo7/x6uG5xJ3oKHt594oF1bW+jHDeMknNr3Y5+dBc8zJ/ZgWkdjawhRgghexEUxAjZA+gwHGJW1KklpJWj5eLL7Uv3mqJWAttOEJTbqBbPHdQQxKpGKaoVjdwaYnEnkdtmNQHBij92rKyI4ye2cz/2pEUmikRtW4HJunwGPB+5jJRriAXxWmfW4WSOW3Yg+aFDrCmMv4uEsFLZwdRT8CLRy7qHin66INbamI3dI4GqqSEW9tOKKKkOMd8IRiU/gKr517qAepORiQNerEaYxTqIdvTFHWLVIhNr1RBLiqWRkBhUClo9Ax7am3LRsfZvK88IbGnIouQFg0YmRg4xNzIxX1lDrKu/cuySIpzrpPKDoMIh1tKQje6hJNYFaO/7emIP25pyMVFuoBQXVpPs7KuMfbSRiTFBrOiV69klIxPpECMjwNzpHQDA2ERCCCGEkHFCtb8/hsL1j3WiKZ/B6fOnDbuN0+ZNw46+Eh59bmdd2z+xbhe+ceNSHDt7Il580KS69pk50QhioxWbuDR8xrUOsW29xREZX0IIIaMPBTFC9gD1aFLJF9yB45AZDD/htLFYYWGIepgTg1h2iCXrSSW3rdbFag4xu70bZaiqKDkPkO6+nuNscrFxhXbbhjoiE61wU3IcYtlMpSDmCk3ZrEDEuLG8IO4Q63cEsVJQFrNKgXHalR1i8XMohg4xK3qVo/DK4k68hlg+JpT4gYnwy0VRjmZd0uVk1xkxrBz5aGvUlSMTzbGsUFKthti2nlAQy8YjE63zrq0pF6tXZscwSVIks9sUUxxiPWEdLHusKe1N0X5N+Sy8wI1MrKxPZx1iJccll+YQ60+J06gWHWn72FeM79PamEOuSg0x6+6qVhPPEhPEGnOxPvQ790kau/qLsc+uQ8x1gfUV/JggFotMpEOMjABzZ7QDAJZtpCBGCCGEEDLWPLutF0d/+eZh1e6ylPwANz6xAafNmxb722KovPLIKWjIZnDr0o01t31uWx/ef/lCTGppwCXvfTGk2mzdBLNCQWz9aAlinV3ICHDktHZM6zB/n27upkuMEEL2BiiIEbIHqK+GWPzFeuTwqtMhVjUycYj1W+zWgZb3rRYB54pnqX2rcug0h1iQcIi5opaXEBDKrqRSbL0VaZL9sXpYYy6T7hAL64UBQEbikYkAojpduYzEXEZAPDLRD9SJ/AsQqEZ9svvY7a3wZOuEpUUmxlw7SYdYoMhm4EQ5DhaZqDGXXckP0JjLIJ+VaDwmhZGJ3QODRyZu7013iPUWyw4xc57l+zlN+Kkm4Frxs+xwNGJbW2PZKTWtozHaL5/NoOjroA4xN57RLm8OBbFamfJJh5jrnkpGJmbE3GPVaogNONGNyT66xCITm+KCWOQQqzMysa/olWuIxSITvUhUa8hm0NZYFl/b6RAjI0BHUx6zJjZj2Ybuse4KIYQQQsjznqWdXSj6AX551+pht3Hvqq3Y3lscdlyipa0xh5ceuh9uXbpp0Hqz23uLeN9vFsILFP/3gRMwtaOp6rZJpk1ohAiwYefoiFTLNnTh4P1b0dyQxfSwX4wKJ4SQvQMKYoTsAQKtHX2YdNHU6xCzL/s1SF8+1MhEV+TyHLdTGlG8YpVD2Ifb5CQuu58riiRriMUiExMRc82h66oncoiZ5Y35dIeYFUsmtuTLNcQSgliyhpgbU2cFjlxGwsjEsojiHqrkB1FdtJKvUZ2vhlwGhVD8sALKjlBYSkYmlpzIRDd6r60xFxMM/URkoj3nnqo1xMJr6WnkAGvIlgXC/cIYwt6Cj4IfoCGsx+YeHwC2h5GJVigqi5Om/1ZMscJNQy4zaA2x6LNfFuyA8n2rKNcQsz8jU9tdQUzg+UEUi2lFnrQ8+pIjZramOMTSqOUQcyMTWxtzxrWXIiA35TPlyMQaDjF3edIhNlDTIVYWxAqej96Cj5YqkYkFR2BuiznEyuIYIbvDvBkdWM7IREIIIYSQMWftjj4ARtRauWl4E5b++lgnJjTn8cojpux2f06fPw1rtvXhmS09qev7iz4+cPnD6NzZj1+fezwOm9o2pPYbc1lMaWsc1cjEeTNMRPjUcMIm64gRQsjeAQUxQvYAqlpTECt6QUw4qreGmBWOKh1iQery2n0ttxvUeHFf0yEW7p902djtXaEk0PhxXPdY5B4KTJ9s3J1bGwpwHGIJscV+ntCcLzvEnDpZGSm706IaYq5DLGw3l83A84Oq4+EHGouwDNTEGjZmM9E+VrCytbg6QiGiv1TpEHMFsdZQEFNnzDMZiZxsVhTsTotM9DUaw4LvR2JgPpeJYietQ6y34KGUEpmYzQhaGrLY3pNwiEWRiea4VlixDrHmfLauGmJWJLLX0nVI9hRKaG/KRe1MdSIT81kjuJUjE200ZeU96cZd2sjIgje4Qyw5Du2DOMRsNGFaDbH2JiPouS7CanXAkjXE3D7Y2MVq96BbQ2xHbwlFP0Bb2C9X9Aq0HK/ZmMugJZ+N/v9hDTEyUsyb0Y7VW3trOjEJIYQQQsjosm5HP5rzWTTmMvjNfWuGvH9/0cfNT23E64+ZXjFpcDicNm8qAOCWpZsq1nl+gP931WIsWbcTP3nXi3D8nMnDOsbMic3o3DXygtiu/hLW7ejH/JlGECs7xCiIEULI3sCoCWIi8n0RWS4ij4vIX0RkYrh8joj0i8hj4dfFzj4vFpEnRGSViPxU6g0HJmScU19kYvnFNeA4v+p0iFUTGIbvEKteA8xiu1atj1aMS4oKaQ4xVY1cVG4/gLibqOgHjkPMi7XTGC6vrCFmPnc0GYdYEChKvsZqiFnKgljlsnxWohpcaZR8dWpYGfEqI0Y8igSxsM/bEg4xG6dXHMQhps41CQJFRgT5TLnWmdt+vF9ObTPfxAbmEw6xKDKx4KEYRiomaW3MRUJehSAWtmPvYRsN2ZzPxsRNt09pn5MikapGkYmRIOZEJuayGSM0DRKZaPH88rWzrikrMFWjIjLRcVkFiRpits20GmIdjnPOipP11hDLZwePTHR/xnc6DjH7B1k5MjHu+tvpXMtMRtDWkIMI0JKPb0fIcJk7vQN+oFi1OX3mLyGEEEII2TOs3d6HOfu34i0vmoW/LF4X/S1QL7ct24S+oo83vXD34hItMyY045hZE3BbQhBTVXzpr0/htmWb8NU3HYUzjp4+7GPMmtg8KjXEbAKCdYhNamlAPiuMTCSEkL2E0XSI3QrgaFV9AYCVAL7grHtGVY8Nvz7iLL8IwIcBHB5+nTGK/SNkjxFouTZXNQp+EHdw1FlDLKginFkRopYQl8R1iNUSxFzxbLC+5RM1lSKH2CCRie6xXUGl4AWRUGRFGM85jkilCGjbmtiSR0/Ri0SXcmRi+b/CbKjDu3WgrDiWTakh5uIFQeTUsg6xjEhMELM1vqpFJha9IBJ3XEHMOpqKkfPPrM+FYklaDbGovljgCHVeUHaIZTORy64xn0FLQxa9hfQaYgDQ3piLaog1hsfNZExEoHWaVTjEGrKpTqjkvWVrqCXFM2Z5gOEAACAASURBVFVznduacpHry41MbMiKcYhZQczWIEuNTAyi9S1RZGINh1iVWmqAGdfeOh1itlacEcRqOcTKY9DWmIuJk9F94uxrYzoBoMsRxDZGgpiNTIxHIe7oNds2ZLPRubU15JCpUjOQkKEyb0Y7AFNjgRBCCCGEjB1rd/Rj9qRmnHfyHAyUAlz98Noh7X/9Y52Y3tGEEw4enlsrjdPmTcPitTuxpbssJF24YBWufOg5fPRVh+Lcl83ZrfZnTmxC587+mpOMh4p9tj0qFMQyGcHU9iY6xAghZC9h1AQxVb1FVe2bwgcBHDDY9iIyA0CHqj6o5rfVFQDePFr9I2RPEqjWfAgrekG8PlGNOEKLdZtURCZGwszQ+woYUala3KImhLBqfbTrcxWRiQj7Vj0yMSaIuQ4xRzCy8YN221wmg6xIhUPM9q+jOQ/Vcqxc2SFW3jZyiGVTIhMzmZi4lMTzy3F4XlhDLHKIhVGL1qG0PekQc6Lw0hxiVhQpea5DrCzWeUFccAPKTh/PDyKByIhCinw2g8ZcJhKuGrIZtDXm0DPgRTXGkrQ1lQUxVyjKO04zew/3FX2ImH7XU0MsEsSC+LYDno+Sr8YhFo6dFZeA8Jr45XhPG1tpxTMrfNl1to2mfL0Osbg4lKwh5jry7LGS+wAmMhEwgla5Xlr6fVRMOMTiNcQq3WVuO24Nsc0Jh1hrwiGWdPu1NeUYl0hGlIP2a0VTPoNlG4ZXp4IQQgghhOw+qop1O/owe3IL5k7vwMsO2Q9X3L8mdRJhGjv7irhr5Wa88YUzUif/DZfT50+DKnDHcuMSu3bRWvzglpV464tm4XOvO3K32585sRkDpQA7+irLCuwOSzd0Yb/WBkxxJmpO62ikIEYIIXsJe6qG2AcA/N35fLCILBaRu0TklHDZLADrnG3WhcsI2etRrawFpgkHVtHzYy/v7fYlP6iov7Jma68TnWeWVY1MHOJsKFfkquYQs4uTwpjL2y66H7998FkAiGL9yvtXCgKDO8TKy9/5ywciQaG34KG/6Ef7ZTOCbEac+muKaxetxYqN5mWsFZ+Sok7WSWfNDBKZmMtKWIcq3VXkBVquhRUEUQ2xhrCGmOsm6gqFqwqHmBuZ6PTL9rXg+9F4GYdY2QW2tacQnRtQjvAr+eV+FTzT/8bQIea239aYixx0aQ6x1oZc1I673v0+En6KPrIiyGczGCgF0TUAgHU7+rCtJx4n0V3wMOeCG2P9B4Cufi9stxyZ6IpS+VBwc7Wlkh+EsZASc1eVAo3EptZ6a4glxsGtIearcYjZe8UKT6kOsSgysXx93ZpzLiXn56CtKSmI+RX9drd3a4hFDrHwXO2/9raqEMQac7GxJXsOEblMRDaLyJPOsq+IyHonYvr1VfY9Q0RWhHHTF+y5XtcmmxEcOb0DyzfSIUYIIYQQMlZs7SlioBRg9qRmAMD7T56Dzl0DuDWlflcaf39yI0q+4uxjR/YV3bwZ7Zg1sRm3Lt2Eu1ZuwRf+/AReftj++M7bXoCRqKAyc6I5384Rjk1ctqEb82d2xPo4raMp+vuLEELI+Ga3BDERuU1Enkz5OtvZ5r8BeAB+Hy7aAOBAVX0RgE8DuFJEOoZ43PNFZJGILNqyZcvunAIho8YfFq3FK7+/AEB6DbEbn9iAE755WyTmFMO6Tkk+/YclmPvFf0Sft/YU8Jof3oXblpmHV+uoUQU+fMUi/PyOp81yP7222GBc/9h6XLd4fdjn6vt6QYBDvnBjVIzXCmNPrt+FW57aCAB45Nkd2NJdgAiQTThm0muIxWsnuQ4iP1Ds32ZmX63e2hsJS90FD/O+9A9886ZlAIyIlc0IfF+xtLML5//2EXz2j4/jZ+GYVBPE3Ii4KDLRWWYdPzkbmRj2M6l7nH/FIjy3vS/qc7KG2Lf/vqxiLFMjE1McYtaxVXKua0Yk2uamJzbgrJ/eC4Xi4P1bAZQFmpIfRONpYwMbcpkKUautKYfegodCyU8VxFz3UDVBzLqQ+opeJNjdtXILXvfju/HJqxfjJ7c9jZd/dwE+/6fHK9oHKsVV68BqaSgLYi1Orb18RlAKglhM5tsvvh8X3fkM8tlMPOIwdOmZNupziCWdcjMnNkeCkh8odvWXopmBts20GmJWKLzn6S3oLZaF0cP/+yZ84spHAQA/u/1pPLh6W3SeuYxgSntjag2xvqKPh1Zvg6rGIhPdWgD3rtoGoHwfZDKC1oYs9ms1/d3aXYz1e9bE5uiPRrLHuRzpMdE/ciKmb0quFJEsgAsBnAlgPoBzRGT+qPZ0iMyb3o5lG7pGPKqGEEIIIYTUx9od5m/UAya1AABeM28aZk9ujv6er8X1j63HIVNacdTMIb26q4mI4PT503D301vx0d89giOmteOifz0u9W/R4TAr/NtmJOuIeX6AFZu6o/phlmkdTdjMGmKEELJXsFu/ZVT1NFU9OuXregAQkfMAnAXgPWEMIlS1oKrbwu8fAfAMgCMArEc8VvGAcFnacS9R1eNV9fgpU6bszikQMiL8+p7VWLBic2zZ2u19eHZbHzQUw5KvAtfv6Me23iIGvLIQcsiUVvzHaUcMeqzegmdexIdOEN8Rl5Zt6MKKTT0AykLZUBxiv3/oOfwudHUlHWwuJd/Ux1q4Zrs5RrjdWT+7F+f/9pHYtlmRmNPJtg3EnV9BEH+x7/a7FAQ45fD98dkwNsGKGknnnOsQ+/7Ny3HP00Ywb8yZF/5WfNrWax5Uo8hEqXSDuSKEFThMZGIQiVLN+XhE3mYn+7wURSYal1Rv0cMfFq3Dvxx/AI6dPTHaLqotVYw7xDJi/kC48sMn4r9ePzf6o8Ceu9s2APzmvjVQKK4+/2V46SEm190KHSXHdVbyTeRjPiuxaL+mfBatDTl0D3joK/lobYjH6wGmhpjFFYrs9w25TDTWfUUfuYzExvH6xzpx36qtAFB3bIV1P+UyEo17YyKuseTF79Un1xs3SjYjMcdToGVnlY1MLJQGd4glReqXH7Y/7v7sq9HWmMMld6/GghVbMK2jCUCtGmJm3Vf/tjTm4goUWLRmBwDgf29diXdd8iB6iz4OmdKKuz73akxtb8Ih+7dhengM+//Fuh39eOclD+K7/1gRc1p2hwLioVNasWTtTgDx2MhJrQ2YFc4M3dRtZjDaMfrO247BT8950aDjQUYHVb0bwPZh7HoCgFWqulpViwCuBnB2jX32KHOnt2NHXyn2/yMhhBBCCNlzrA0nbc6ebASxbEbwvpfNwcI12/Hk+l2D7rthVz8e+ud2nP3CWSPi2kpy+vxpKHoBJrU04PL3vySaSDgSjIZDbPXWXhS9APNTBLGegheL1CeEEDI+GbXIRBE5A8DnALxJVfuc5VPCGc0QkUMAHA5gtapuANAlIi8V81v2XADXj1b/CBlJvnHjMrz/Nw/HltkX9KrmpXdSl4piB0MNqOgZ1855J88Z9FjRfijXkgJMfJtq+bN1iA1FEHPrhvlB3NV21MwOfOb0I6K+pvUpjYxIzIHlbu+6wAIt9zm5zvMVOUfcsA6t5LlFDrGwztfRMydgWkdjtL0VxHYkIxNT4hHdZTaWMJc1DjHr4GkOhYbJrQ0V5+0HiiAw59+QLdfqOnxqe0zQ6WiKO8RUzfnZ45906P44/xWHRsKMPbYfhJGJTj+PmNaOY2dPjASqlnw5ps/SVzSCamMuG3d2NZj6UVt7ClBFzFkVbdM4uEOsrTEXnVt/yUc2IxUOqy09Q3spbu+DTEaiWXhubKGNsbT37YwJTTjvpDkATD21jsQfVIVSvIZYwRvcIZZPzE4UEcye3BK7P7541jzksxKNT1oNsWQ/Tp07Ff/v1MPw9hcfAC8RnXjr0k1ozGWjGY1feuN8XHbeSwBUOtouvuuZ6H4Gyv/PfOa15cx9N9v+4n99Mf7rzLkAgE3hDEbr/Gtvykc/I2Tc8AkReTyMVJyUsn4WALci+riLm7Y/t7b4OCGEEEII2bOs22EEoQMmldMg3nH8bLQ0ZHH5/WsG3feGJRugCrzp2Jmj0reXHrIfvnDmXPzuQydiajgJcKSY1JJHYy4zooLY0k7zTJt0iE2fYP7mYh0xQggZ/4xmDbGfA2gHcGtY++LicPkrADwuIo8B+COAj6iqnRX9MQC/BrAKxjn2dxCyl+LW4tLwK74+LlgVvQAN2WxFDF+SqHZYQlSyjq6yEyiIbV8PvuMKS0Ym5rOZSACqFMSqHyOTiccPuttbASwjRuBzj+dG4HmBIpctC2vFKudmBSI7DhkR5DKZaLuqNcTSIhMdUSNyiGUzpk6YH0YhhmLPpJZKQawUBAhUIWLasjGP+axEx21pyCKfM8fpd5xKfUUPmcTsu0qHmBGJ3Hg+K0ZZ8awxn0FG4k46e+7tTblou6Z8JnJT2Qf4NEGsamRi2E5rY1lk6yv6yGUzFeLQliG6RKzQlRHgx+86Fn/8yMswsaUB919wKh78wmuQD+uzBYHiqJkdeOALr8Erjyw7h90+A2UBrDGfiX22JCc9JgU9i72nj5k1AS8+aDK++eZj8K4TZgMYvIaY5eD9W/GZ1x6JtsZcap3AhsS42XHsL1Y62jZ3V/7RddTMDiz72hm48z9fFTnYAODoWRNw2NQ2AMDGXeYPw9YG1g0bp1wE4FAAx8LETf/v7jQ2VnHTc6eblwXLnTqChBBCCCFkz7Fux/9n783DJLkKK99zb0QuVZW19FJLV3dLLXVrl7EkhAABAgRm84KxPdh4AWy8AOb5PfzssfF4Hh4vM4zHw7zPn7H9bIx3vIwxBhthC9t4wwYkjBBCEqglBL13S13d1dW1ZUbc90fEjbj3xo3IzOpasrvP7/v0VWZkxI0bEVmtyjh5zlnE9pG69RlvfKiGb3vmHnz4gaN4quJLix/63BF87Z7xLJZ/vQmkwA+9cP+GjC+EwO6JIRw9s34i1SPH5lEPJa6etOc7PZp85jpxloIYIYQMOhsmiCmlDiil9hrdF29Ol39AKXVTuuw2pdRfGtvcn0Yu7ldKvU25CgIhFxH67auQOsRK1tM3/NuRQj2UXWMIlCOkZQ6xOBmrkz3Pl/dKnIo9enxTcNLuq2Su9qBVv6mBEAVxJxPE0vFrgYRSecyjOX8giVYMpcxECL0/Y/UsYlAKkbnbpLSFrTwysVwQ0/qSFZlodojFMdpp35vuRitziCmFLNZQO8RqoTQEpDAT4EyhY2k1LoiIWhAx3XFS2Menj0f/bIQSYSAtse3pBS2I1TIBTTvvRhpB5kDSXWAmZvxgI8hf16LeSD3M9r20mjjE3MjBfiMk9PtAikSwu31fEgc5OzGEmfEmaoFIHFZKZddxb5qN784ZyMXBZlg8vjuu2l447/XQ//uo96XP4WuftRfXTo8C8HeIjTnOK33daoHAaie2rlGy3B5D709HJprMnS/GTwZSYKgeYJ/ng6Wey9xiG8P1wCvgka1HKXVCKRUppWIAv4kkHtHlCIC9xvOBi5seH65hdrxJhxghhBBCyBZx6PQS9m4rdgW/4c59WI1ivP9TX/Vud/DkAh46Mo9vumWgAgj6YnZiaF07xB4+No9rp1uFz2vT46kg5vmyIiGEkMFiIx1ihFzWmA4w/Z/1epy/rpTCapREJna7N507z5KfWkRKBJh8P23DOdYrkbG9K4hJQxBzXTXVDjFRuOGuV9cdYvVQIlbKikyMPA4xd5xImYKd7vlKBBLdsWVuU3CIpX/ESk+HmLldzRTEsg4umQly2zyCWCfKRblaIA2HmMxEo9FGmAsdhiCy3IkKMZN6rtohFsUKgbAjE80uL72vmhSW2HJ6segQG04dQq1GLtr4XEOtsshEQ+DTjxdXO0mHWA+FyNfPjOLrn7Ere24eei6I+bcNA5l1pOnraEaBjDrOLC0omc610UaI3/u+O/Dbb3xW4T3mftDR6PV09KLvNRN3Hvq61dL5uw4xd7/6+bLHITa3uFpY5hPlzLF0R5wrGJLBQQixy3j6GgAPeVa7D8A1QoirhBB1AN8B4MObMb9+uGHXGB49RocYIYQQQshWcHhuEXu2DxeW759s4YXXTuIPPvmVQgoMAHz4c0chBPCNz9hVeO1iYXaiiWNn108Qe+TYPG6YGSss16kcOpaeEELI4EJBjJANIjZcTKqqQ0zlrp9GKAtuqmx9Q0BLtrOjE7WAVXCI9SOIxblrK47tbQNDXOq3QyyQuRsmmXvymukQi1N3m17X3LfuEHPdO2bPmN5OSoE4VkmkoCMY9RKZqM9/zRAUgiwyMRHbOnGMWpALTTt8glgamSiFQD3M160bgtiIIYiZotXSauRxKhU7xKQUCA3hpOYIYvVQohZKOzJRO8QaoRXdCAAtwxXmjUw0ltU8zrQRo0NMn/+yyEGTsWYNb3vxgcJ4JmXOyURQSsRHn0hViExsJ/1swnhvBIHAXddOWo69bC5dBLGGZ67utdPHaG+fX6NOrDIHYbZfZ9zcIVb8oKrfz+bUQ0+PmYn+XaAgNhgIIf4IwL8BuE4IcVgI8SYAvyiE+LwQ4kEALwbw9nTdWSHEPQCglOoAeBuAvwHwCIA/VUp9YUsOooLrd43i8VMLWPE4HAkhhBBCyMYRxQpHzixZKRom3/u8fTh5bgUffeiYtVwphQ8/cAR37t+x7t1em8nsxBBOnlvxCn79cvLcMp5aWMWNs0VBrNUI0WqEOM7IREIIGXh4J4yQDcIVpFzRSAtbUayyP87qgSx0GGk6sUI97ccCcoFMO8QSF1qyXBnurn46xMztXIdYIEUmFriRidrlZo5jbpeJTIFEO4qMyMQkGlAKgVgljrFGmMQLmmJXFCuEgSw6xIzMRC1CWA4xKTLhAQAataTjSjtqtNhhjpuNYwgKtWxsiU7UQTuKEQYS80tJVJ0vMjFxiCVCjhZt9DnQwlWrEWbnRkcVAnncoEnNcYgplXemaTIhLMh/hlJacYxPn88jE815mD8BvyCmlyVRjUUhbqQeoGFEEYaBKHSI+aiFwhKWGmFgnQ8ABaEq29YQaX3rjDaKHWKBcY07sbLOYeG8lzjc9Da6i8xESgEp7N/5UUcQ0/PW5+7csh176DrEwooOsbnFZNuRephFUvpEOZOxoRqOnl0uCIZka1BKvc6z+LdK1j0K4FXG83sA3LNBU1sXbtg1hk6scPDkAm6aHd/q6RBCCCGEXDacmF9GO1JWiobJXddM4urJEbzvE0/i1UY04oOHz+LJpxfx1hcd8G53sTA7MQSlkvOw1+OS64eHjyYR4DfsKgpiADA11vD2OxNCCBks6BAjZB0xv3WklC1IudGFZhdYJoiFEgL+G9la+Mr6s5werShWiONExGob0YNVcYYuUayM+aIQmahj/FZdQSxWOG/cqDeFANshpt1DqSAWqVQwS85HJ1a5w8gYpJ0KZ65YYUYs6j4vKUUS/RgnHVumIBPKpIeq4BDzRCZa2wV2HGM7UqgHMouO9ApiqTAphR1fVwuE5ajKhA7DxbXYjgpOwYJDzNOR5naI1UOJWiAscen0+STCYbRpOMSyDrFcHGl5OsR07J/rXmoYx2O+FhgOtionUi2QlqvL5xArSwDUgtVKJ7bW+dMfei5+7/vu8HaI6eutr4sliDpCVJlDTP8u+LrIzLE1Y0P2PPT7VY8/v2R3q7ndZXo8s0NsLL0ec+n7WTv9AH9sowkdYmQzuT6NlWFsIiGEEELI5nJ4LokLLBODpBR445378LlDZ/DZr85lyz/0wFHUA4mX3zyzKfPcKHZPJELgevSIPZL+LVsmiE2PNukQI4SQiwAKYoSsI6bLQ+s5ZQ4tvdSMTKzqEOsYzi3zp+kQi1JXV+S4q3olMp1lTu9ZIHLhyBeZuLCc39A3HWTS2E6LTHn/WdLFJYVIIhpjlYkhpsNNqUQQcF0v5vxMh1gU5ZGJgeP+aTXCzCXlRiYKkUfzmc4yLTqFge4Qiy0hatuwzyEW57GBhrhRC2Umgow2Q+85XfZEJmoxccXoEEsiIY0uL8chVgskwsDpEEuPvdXM+760+GWKI8MVHWKuSJQJfPXAErNCmUcm7mgVz5F5bKZDzCdClUUm6vO00o4tEfGOq7bjrmsnC86slU5ccAGG0hbxfMdWtl+fQ8w3zkgjxP/5kmsyx5qO5NS/E/Ppvx2hIx6745n69s5WA0DeIWYKYlUdYkAuiPmcgISsN/t2DKMRSjxybH6rp0IIIYQQcllx6PQiAGBviUMMAL71tj0YbYb47U88CSD5rPmXDx7Fi6+fzD43XKzMpoLY0XUQxB4+No/dE0Ol52RmvMkOMUIIuQigIEbIOjJviEI+wcok9jjEtDjkQ7uhdASjygQ3PV4uirWNKME+9DDEaT+WnpflwJIiExCKgpjCwkouBpoOskCKzLmT3+TXDrE4c4jFKnFe6cg9LYjp+YSBHX9orqP3AyQClBb23A4xKRJBTJ87Lbxot4/pFDO3ywUUiU4cZ51mGtchVgvy2EYBW9ywO8SCbN8mS+2osLyROcTy940bmdhwOsQaoURN2h1ieWSi2SGWRiY2e4tMrDuuqCwyMe1E09cikDITfMyetYlh+wNE3XGIeWMIS34v9DEsd4oxk+4xAalDLBPC9Dz91908Nhf9XmyUOcScqMh6IPH2r7sWt1wxYe1TO9zc+E13v77oyYnhGoQAzqSRiaaI2atDzI2UJGQjCAOJ62ZG8ehxOsQIIYQQQjaTQ3OJIKaFIR8jjRDffvte3PP5Yzh+dhmffOJpnDq3YkUoXqzsGk/6z9ZDEHvk2Ly3P0yjIxPjfm7CEEII2XQoiBGyjlQ5xNzkQvN1KzKxzCEW6chE2yGme7SSyMTEdRWZkYlrdIjFKhffALsLzI1MVEpZYmC7YzrEfJGJ6THFCrVAQKQdYlEcZ8KP3rcW5UJH/NHHrNGOmDBIetbiNK7QFTtMgaSRRSamczXWNQWJbOw0MnE1iq3XXYdYLZCpIJZ3iJmv5c6smrfraandvUMsVgqBEN7IxJohjLkOsXPLHdRDiUYYZCJLyxOZOFIvj0xslLimRhwHWSjzYx8bqmX7m3C+UVcLRFeHWJm+o6+N6xDL5uzpEMvdhPk8NevlECsT1rSAVnMjE9Pfnx2p66vMIWbSrAVJBGjqEDMdft06xLLIRHaIkU3i+plRPHqcDjFCCCGEkM3k0OklTI81rC8g+nj9c/chUgp/+Kmv4EMPHEGrEeLu66c2aZYbR7MWYGerjiNnLizKcLkd4YlTC6VxiQAwM9ZEO1JZggchhJDBhIIYIeuI2QPkdoiVO8TyGLx6IEuj4TqGUGX+zMZPRaA4th1ikavEVaBjC/X8Y8eBpW/Kd4tMLDjE3MjEOBe7AikgzA6xmh2ZqI87DGTBNdVx5pf8lFnMYiBtMUpKYQkk+rWgizBSM6L1OpFCxxHEXIdYJ42t1B1ilrhmdIiNNkOvQ2x5tSiIFTrEYr/YZq5bCyRqgcSS0e8G5CKRXl9/ONLLG6EsdGkBRmSiIxLp94MW0fQ1lMb5b4ZB5mByIyaSaMd8zIbnw1qZQ0xfmzKHmBuZuGz0s+XvmSqHmH+/erUyh1jgxDDqfTRr9nuu7jjEdqbRknVnvzVPBGKzFmC0EWYdYkPp+ZcC3veVCSMTyWZzw64xPLWwyqJxQgghhJBN5PDcIvZu8/eHmVyxYxgvvWEaf/ipr+KjDx3Hy2+a6SqiXSzMTgxdsEPsi8fPIVbAjRWC2PRY4kY7Ps+/dwkhZJChIEbIOjJvOMTMDiwg7wzLSBcopTKRQ7tkfPeys8hER2BzHV1RbEcd9tMhFitlCW2m4CSF4RDzRiaaDjFzu2IvkukQC2XaIZZGNBYiE9Nz43OImYJdFn8nkm0jpSx3mv5pCgB5hxjSbYsimLlt4hCLM2ebZmzIFhX0nNtR4loy162nIhWQCEjmPvV+FtuRtdycT+YQixUCaYs5WYeY8TMM7MhEIHd6uduNeJxiJsP1AEIUHVz6/etziOmxw0Bkgtm466hzBDafA61cEKt2iLkOqFVPh5jbM2fic6sB+Xu4zC0XegTVZP1ctDLnrx1iZZGJMhWOTRqhRKsZZr+nI2kXXLf+MAAYT2MrWxTEyCZx/Uxy8+DRY4xNJIQQQgjZLA7PLWHv9u6CGAB87/P24fT5VZxb7uDVt8xu8Mw2j9nxCxfEHk67cHsRxE6yR4wQQgYaCmKErCPa5QHYog/gi0zMO8HMyETAf/O/7XSRKWN7/VOpVAwyhKI+DGLWdrqTTGP2VbWjokPMjIs0HWJSFiMT9dw7cYwwSDrEVLp/LR64gmLSIeZEJjrzAxIxQEcmCkOM06+bAkkuiIlsrprQ47wKA4FOlFwv83VXgNCncTWKISUKLi6931azZh2TFoyiWJU6xPS5jTwdYll3mHaKBRI1KbDctq+Xdk3p66jdSPrcaGHFRQiBVj0sOMR0r9mI4yBLHHq5mDicvu5GJrqik18Q804pO7eJQ6z4unssvg4xM3bSvZZlkYn63JV9azJ0RFCNdojp65gJYm6HmGe/rkusWQss8VI78Lr1hwFGhxgjE8kmccOuUQBJ9wIhhBBCCNl42lGMY2eXsGdbeX+YyXOv3oHrZ0axs1XHnft3bPDsNo9dE00cPbOU3YdYC48cm8doI6w8l9NjSfz9CTrECCFkoOGdMELWkXPL5ZGJ7h9fWfRhnN8c1zfffWYYt4vMjUzsGEKJKVj16xAz529uGxhuK1+HmHnspoMsEMXIRD1q4hATUCo5nnYco1ULEUiR7butBbEuHWK5qAUrMlELHNpxpWMBTbHMjdDT+8seGwJKJ3XONWvSu65Ju6M8sYa5a6rVCKx9jjZrmVOo0CEmix1iUggrYlMLLzXLISYK10u7grSQlTvWQuunj1bTJ4g5DjHtCjMiEwMpM8FvYrjYIWbiFcRKzrG+Nvp6u4w2atmcVjsxVjoxRsMwnZ8dX+jbj+vU0mih0PLk7QAAIABJREFUuxeHmHm+tIC20taCWLKedpdud9xzJoEUgGH2a4TScngN17VDrHdBrOpaE7KeTAzXsWu8iUeP0yFGCCGEELIZHDuzjFihp8hEIPkC5K9+121YXI28EfoXK7snhnB+NcL8UidLyuiXh4/O4/pdo5XR9FOjjEwkhJCLgUvn/3CEbCLv/ecnsO8nP4KVjh1FZ0YmupGGriylX1+N4qx/Swsavh4xLTrk3WP2+Hm3lC1k+TrE/u3xp3HGU/RqO8QUTB1FSpH98eeLTDxX0iFmxhbmkYm5iBdKCSH0/hKBLBAim/cH//0wgES8cAUPX4dYKGUWHSmFyNxAmUMsFRCUys+zK4yZy/SYQOIa60Qx2mmH2D/++Ivw4bc9r/SP4lVPZGItkJmDq9WoWdGIppvJPVaZuq30uY3T4zPJohJNh5jng4x2Ben3TJiJVgJDjuvIZaQRlkYmNtP9j6UOtECKbOxQisoOMd9xmJR97jDn4nNWDtUD/Nmbn4v3vv52AElfX/ZecZxi7mPfc03HiTl1saIszX60dH0dY2l2iDVrMutfazu/Y+Zc9u0Yxk2zY3jzC/dbDq/MIVbSe2ayYyT59qIrThKykVw/M0qHGCGEEELIJnFobhEAsGd7bw4xALh6soWbd49v1JS2hNmJ5PiPrDE2MY4VHj1+DjdUxCUCyWe7HSN1nGBkIiGEDDQUxAhZA//z3i8BAJbbseX8WjFuYrsOrtgRpvTTb37PJ/CWP/x3AGZkYnGfxQ6xxJml99M2Xm8bHWK6Z+u73vtJPO9df4+VToTX/eYn8abfvb+wD0tIixWi2HZ6afHGdRzFKoms07SdyEQtGOnjM89NEpko0i41hSAVvqJY4fxKB7+UnuvtrXoxMtE4zkzUSl1cbmSi3vTOAzshBHD15Ig1R3MMwO8WC4Nk7HaUdJ9duWMEz9gzka13464x1AKB//DMPcl56MSQwhZ46qFELdR9ZoHVDWUKUT63Uy2QaHdinD6/io4nVrFhOMP0T5+gUxaZCCQOsCpBbN+OYeyaaFrLVrXTLN2vjv2zzmcgMgdTN0FM92yZ+ERiwI4mLIsKvH3f9mxOy+0oFzidOE33cT2UpfvVYmxpZKLhOqv5HGI6JjU99nPLHTRrQXYuTLE3GzM91snRBj7yIy/Avp0jlkNspA+H2M27x/Ar33kr7rp2suu6hKwXN+waw+OnFgpfqiCEEEIIIevPodOJINarQ+xSRQtix86uTRA7NLeIhZVOZX+YZnqsychEQggZcJiVRMgaWErdHVC5uAPYzintcCrrEPPlV1d1iLnjuJGGnTh3iHViU5hL1vnEwacBAIsrydwfO1GMrTKPRSnA0JsQGB1ePoeYsUs7MlHmcYWuQywRlgQ6QiCOgSiOUUv3E8UqEw2+//lX4UXXTmZFthp/h5hAFMeIY5XsN9UitFPpmVduw2M//0rrWANPZKIQIotIdCMT21GMemhfo/t/+qUYbYZohAHe/6mv4n9/5jBWUoeYJY4EEldsH0YjlNid5o8HQqCjlCVuBJ73QD2UePLp87jt5z4GAHj2VX6H2JU7hvGi6yZx6xUT+MjnjxXG0V0+7Y4dmQgA24ZrhY4vk1/5ztsKkZ7azaRjHbelsX+BFJmTyuwQcwUx1xHmOtAA/++EO3ffOcteS69tJ1a5ABrYwpj72DcPjf7d6+YQqwV2ZKZeX7tLsw6x5TaGDEHMFZ2TMfV88/FajfxcDmWCWPfvuggh8A3PuHSKssnFwfW7xtCOFB4/tdD1G7aEEEIIIeTCODy3hEAK7Bpvdl/5EmY2/ULn0TU6xHTCQS9/v06PNSiIEULIgEOHGCEXQCeOLeeX6RArdojZ2/qqvbLIRN++PJGJpiBkOsRMd0nk7Of8ahJt6HO2uJGJsfHc6hBzBDGlYMUrmjfzze202GCemzDIIxM7UeJ60oKY3s/Vk61UoLL/yTLnq1+TQiCKk/MrhchEGisOMZCWCGP2j5loIawW5EJElApi7lx2thqZs0kfZyeKIQScyESBZ165HV/4Ly/PMsa1QGMKYr4YxkYo8UVDyHT1Gj3P4XqI3/neO3DljhGvqPN1N04DAJ599XYAwI2z+R/2737tLfjxl19X2EbTrAUFB9cb79wHALhie/LNwx2tXBDT1yhMO8TqgSw40AodYrXinMvELnPbMjeXu56+PlqYq3KIlaF/3xolDjG9vx0jDasX7DW37ca10y28/rn70vWSfZxd0oJYsp0vMnGorqM78znqc23OpcwpR8hWc8NMIsYzNpEQQgghZOM5NLeIXePNS6oPbC3sHGmgHkgcObM2oerhY+cgBXBd+rdsFXSIEULI4EOHGCEXQKSUJYiZQpF2TOWCmK1MuRGKQG8OMTMy0XKIaUEsFZb0eLGjvJ1PHWI+QcycU6Rsp1kiVCWP24XIRHsf5s18IUR2PDo6Tq/ejpI+JykEYpUcY+gRxPR5KUQmejvEUoeYUlYcYdVnAC0+uaJLTUosIy4IesvtyNvNlR9z8lOLcqawkolrxvahFFgFsG2kbi1zaTVCnDTyyAsdYp45hZ4+qSt3JHGRr7l1N55/zc5MmAOwprz41z5rL177rL3Zc+0Qa0e5OBsGAtfPjOKG2bHCuSt0iHmOo0zrshxiFdfYFDD19bxqZ3IebLE0eXz7ldvwzH3bSsfTvxvNLg6xn/mmm3DrFXms5tRoE/e+/YXZc+00bEeqa2TituE6Dp1eso752un8Q5mOvvRdc0IGgat2jqAWCDx2cmGrp0IIIYQQcslz6PTiZR+XCCSf93dNNNfsEHv46DyunmyVxuWbTI818dTCatY7TgghZPDgv86EXABR7EQFRsWoQn3j3L2/7TGI5Q4xX4eYIYTp8U1BSItUUawyN1kjlNY6APD0+URQaXpcOKawFcewjk0awpYvMtHcj+UQM4Q0fXxmh1gtEJAyj4AMA5m4vJTKxqkFtiDlnhMgFwG0mBYrBWl0iFXFyJn9YyaBs18tYi2tRgVXk7WdMY4Utmjj+6NYC3FjzVo2rs/l02rWcG6lk4/trONzNJnH/d+/9Wvw52+9M3suhLDEsPVi+0jivDq71M7eF4EUeOPzrsKHfvh52TGONkNMjzVw9WTL2t7nECuLTPQJXd71PF1jukfu1LkV47VkvFfcPIN3vPKG0vGiLg4xPa/J0Tqmx8rPcT3It2/WZPb+cEVnAJgYLnazXTudnzu9LR1iZFAJA4l9O0ZwkIIYIYQQQsiGc2huCXvSmP7LndnxoQuKTOylPwxA9tnvpPEZkxBCyGBBQYyQC0ALL5rVtBcIsEUfAFCOBFbZIea5oa1FLr2dchxiliBm9Bu57i1t3x/qEpmonEjGQOY3+d1+o1jZYlq7JDJRCyFZh1isEEiZOsR0FGHS3RVFuUOsUeIQM9Gv5YJYIqKUxSGaaLHFdYiFUiKUIovi0/NfbseVLhxbEBOZgKHjIF30eR5thplo6Ftv1IkadOfrE8RM4e55B3bitivKXU/rxfaRBgBgfqmduRV93VyjjRCf+qmX4oXXTlrbmyKRpuz6mV1uZaJZsv+icHb1zkRM+mpaNm3O0+fQM2nH9nvTJXvfVcwJAGrG/IfqAa5JBa7nXL2jsO624URoNEVV8xufebQnBTEyuByYauFxCmKEEEIIIRvKcjvCqXMr2LudDjEAmJ1YmyB2drGNI2eWeu6/nRlPPgszNpEQQgYXCmKEXACuINY2CrtioycL8HSIFQ0gmaDhu52tx84cYrHtyjIjFbUrrR4UBbFjZ5M/zFxni1LKcrHpCEONlCITJVY7RXGvLDpSiFwU0Dfs8w6xGLVUcNIRkGGQRiYaDjFfZKKrM5iik46yDKTIXTMVwoQpppnUAuF1Fq12iT8wRRAhRBYVWSZULLUTIbXVCLN1ffNtuYKYM55PnAmt/rLN+SffdIi95IYpAMDLbpzJ56GPsURU3GiHmL4O2iG2YLrutDja5Vxpoa9MEAsrnH4m5jUZqgW4fmYMn/6pl+C7nn1FYV0dRWkJrrJ4fYMq9ZeQLWb/ZAtfOb1YcBoTQgghhJD14/BcIv7s3U6HGADsnmji+Pxy9kXjXnnkeNJ9a/ZuV6ETWE5SECOEkIGFd80I6QGlFH757x7DE6fsb7VrJ5LG6hBzBDE3MtHXIRZWuEr0ONpN5HaI6d6uJDIxj3NzIxOPa0HMuZHvzi9SyuofM51eBYdYDCcy0e720sdVcyITO1EiWgnAcIjJzOWlnWbaMWQKSjXnpr/lEIsSsVAIw6nTo7vMXW4KLmGX6EN3PCCJTNSOKF83FpCLpSON3CHmm+9o0xbE3LeJz1nVq2C0nmiH2NmlNm7ePY4n3/X1+Jo9eTeZPnfuNdT4RKYyQaxmrFvlxqp5zsPUaKOwXq8OMS0Wl+XIV/0uW/My3hN6rKmxZuZKNNGCmPvSTemHM33equI8CdlqDky1EMUKX3n6/FZPhRBCCCHkkuXQXJKCwQ6xhNmJIcQKONFnlOHDRxNB7IZdo13WTJgZTwQxfd+FEELI4BF2X4UQcmJ+Be/+2JfwFw8cwd//3y/KlkexsqIPbUEs+Zm7rGzFyRWgAGQ3wX03w7XrK4tMhB1p2DYEM73PeiAL4pV2iLmRia5wpju9NKEUmWvJjIZMjsUWBtsdu0NMZoKYSMdO10udVlp7iGKVxQpGcR6Z6OvVCgOBVWMaWvgJ0v4xpey4wiqBI3MFFRxi0ussMufkH88eOxOAStxEmlYjzNxwvvm2mhcWmVgmQK0321PhZqXEAVLVkwb4j6Ps8tWMF/rtEBNC4Mdffh32Gx1mQY/OLk15ZGJvfV6mSDo2VKtcd1vqvDtvONoA4INvfR46cYx//8qZnvZJyFZyYCr5fTt4cgHXTPd2Y4EQQgghhPSHdojtoSAGIBHEAODomSXsnujdNffIsXnsbDV67t7ePlxHLRB9C2+EEEI2DzrECAHw7nu/iM8dOlP6+pmlVQCJAGGKXpEjBK0Y4pPq4hBzO8VMfKaSPDIxj2DsGE6sjtEhpp1VjZosdYi5zhbXseY60KTRf+VGXbkdYq4IFziRiaZ7LpAi6xDruJGJHTsy0XJredxcQCJoRGmcpNnZVd0v5V8ndB1ipiBXIS6Z40iRC0DdnDujzbCyR67QIeaJeHQxHUhlEYXrjetkcynrSdMfTHzuu7LrZ4pn/UYmAsAPv/gAXnHzTOG1Xnu43OjRfscx5z/RRRCbSIXGc8u2IFYPJYbrYXb92SFGBhkdVXqQPWKEEEIIIRvG4dOLqIfSm4pxOWIKYv3w8LH5nt1hQPI5fmq0iRN0iBFCyMBCQYwQAL/89wfx6vd8ovT1s4ttAMD4UM3qG+pE5d1ZxQ4x14FVPh/f/ewo1oJXPr65b6tDzOg3KusQc0WHoiBmO9DMyESzK00fmy++UY+jt3MFsXaUCGBSCMRxcgzaiRZFxQ4xU4MKnflnHWJCZN1uQpi9ShWOrpLIxDCQtghmiCo+F5PG7jozHGJdeqlaRmSir0NstGkLJq5o5puTeZ42SyiRUuBbbt2NX//u27yv6/MQOgLdB95yJ37je57pPfYyQWyoHnRdB+g9OrIsPrOMZpcOsaqoTnc/490cYsPJ6wuOQ0xT83TtETJoDNdD7J4YwsFTFMQIIYQQQjaKQ3OL2DMx1PXzyOXC7ETi8DrShyDWjmI8dmIBN+7qrT9MMzXWwIlzFMQIIWRQYWQiuexxhSof86kjY2yohnPL7Wy5K0qZUYJRXO0Q83WIaXw39l2HmHZU5fuOjXVzISl2dvzUQmLdd4/bdZJFsd0hJlMnl7svPZdYKUiRHKfpEIvjXBTQgo3edZQKYEIkbrvkuYR0HWJBHw4xKdCJk8hEU8SrEoO0LlMQxKRwnEW9iUvmhw4zMrGsQ0zTaoZZBF8vkYnuKj5BrG5GJnbZ/3ry7m+/pfS1XLix5zMz3sTM+Aw++NnDhW3KtK56kHfOVR1ekL7PlOriJOtTEHOF2cI4XTrETLoLYn6HmMb3e0LIIHJgqkWHGCGEEELIBnJ4bgm7t/UeDXipM1wPMTFc68sh9vipBaxGMW6c7U8Qmx5t4rGT5/qdIiGEkE1iw+6aCSF+RghxRAjxQPrfq4zX3iGEOCiE+KIQ4uXG8lekyw4KIX5yo+ZGiIkrBPk4s5hEJo4P1ayb0Vp40VhCkNMh5gpQVbv1CWI6ElGpXGAzBSvdMQbk3U31QCadYlGxyyly5+OsopS9jhk/uBL5IxO1IGOeBwWViQJaJNCiXieOEQYSUohMxEtiCu0OsbrH+eKKO6bwFceJu83sEKv6ZlxQIl6EgbD2Y0YSlgkh7jh2ZGL1P7mjjTBbxzfflhuZ6HaIecbfuz3PjB+ULwdm56NkQr73f9n1E0JgOHWJdROfatIvxJno17q56X7iFddXCli9doiZTAx36xDTgljb+3ovbkhCBoH9ky08fmqh8IUNQgghhBCyPhw6vWh9FiTA7PgQjp3p3bn1yLF5AMANfTrEZsabODnPDjFCCBlUNvpr5P9LKXVL+t89ACCEuBHAdwC4CcArAPyqECIQQgQA3gPglQBuBPC6dF1CNhTzfpyORnQ5Y0QmmoJYHJdHJuYdYqmQ5YzZizPNpOM4zZTjEDP7xFZSp1o9lIjiYqeXOZ6mIJApZY0ZGOJS2+MQi2KFRpgIE3Z0ZC5m6Bv2yhALQykgZe5qCwKROMTiYmRiWXwhUHSIacdamdhlUhaZWJN2ZKIppNQr+rjMcaQ0IhPDaqGiZXSI+QQZt5vLFYmE5xivnR6tfH0rKOsQ0/jmWXX9htIer27HF/bQsZU7xKr/9/iWF+3H5975sh7G6f2cj/UYmXh+NfK+3mtXHSFbzYGpFpbbMY6e7a/DgRBCCCGEdGdhpYO5xTb2bqMgZjI7MdRXZOLDR+dRDyWu3jnS136mxho4t9LB+ZKoe0IIIVvLVuQqvRrAHyulVpRSXwZwEMAd6X8HlVJPKKVWAfxxui4hG4opaD3+lD/CaS51iA3VA7tDLM67s+qhLAhBQN755epflR1int9MsyMMSBxdVm+XKYi1k502wgDKiB40cb+Z7zrl3DhIKUUmwLgCWyKIIYv7a0e2MKjFDB2VlznEojQiUQi0O8kyLULFSmXj+FxTvnhDvTxKnXtSiszJVeUQK3ORma44wBbhqhxipi4jRC7odXOIDdUCoy+tuyDWSxzf/slW13U2m7IOMY3vUlXpSs1UEOsmPunXq7rGeonY7AV9bH05xIbqla8P1QK8/rlX4o9+4Nne1+kQu3gRQrxPCHFSCPGQsex/CCEeFUI8KIT4oBBiomTbJ4UQn0/d+Pdv3qzXzoGp5N8lxiYSQgghhKw/h04vAgD2bmdkosnuiWZfkYmPHDuH66ZHKz/7+5gZS/rKTsyzR4wQQgaRjRbE3pbeyHmfEGJbumw3gEPGOofTZWXLCwghflAIcb8Q4v5Tp05txLzJZYQp+jxx6rx3nbnUIRYrhcVV2yGmNx+qBZYoFbsOMY8Dq4zeIhNtwcobmRhKq4vLxCeAWc8dwS2UIhNg2q4gFtuRiVrcSsZF1u2kXVW5QyxGLRAQQmQiW5DupxMVIxP1PIA8/k5jRtRp8dCMTKzs/BLaRWYvdyMTzTGqxC07MjGfQzdBTAiRu6c874FWw3YQ9VKQ7OsV22py4cY/N9/7v8r91fBEalbtt7JPbg3OLh9hD+Kby3iXyEQhBH721TfjmVdu976euwsH75qTrvwOEte8yccA3KyUegaALwF4R8X2L07d+Ldv0PzWFQpihBBCCCEbx+G5RPTZQ4eYxezEEOaXO6UR9CZKKTx8bB439hmXCADTmSDG2ERCCBlELuiumRDib4UQD3n+ezWAXwOwH8AtAI4B+J/rMF8AgFLqN5RStyulbp+cnFyvYclliin6zC+VRSYmDjGl7PU7RmRis+Z3iLlRh/nr5YKY7xa6O06s7NhDU6SyIxNVJpCZHUVdBTGlrHUsh1hJZKKvQyxWqhCZaDrEAikgRT5mLUhcWZFSVheaJnPwOOqVz5FjOryqBI58HfufxO9+zpX4vufvy/dhvF4VS2dFJorcGddLlJ2vL01TiEwckAjEfql1iS5cq0Os2/nIXIQV16EXAbUX1tIhVtVJ1gt0iF28KKX+CcBpZ9m9Sin9DYxPAtiz6RPbILaP1LF9pI7HT1EQI4QQQghZbzKH2DY6xExmJ5Lzcexsd+fWB/79CE6fX8WdB3b0vZ9pOsQIIWSgCbuvUo5S6qW9rCeE+E0Af5U+PQJgr/HynnQZKpYTsmGYutBS29/NoyMTo1hZ60cqf96sBViNVqCUghAiiyTUopJyWsRM/alZk/i1735m9tzvEHPGU8qKPbQiEzs6MlEiNrq47r5+Cn/+70eyuZv4BDJzHbNDrCiIpQ6x9Ia83aWWu53CTBDLO9DCIIlMzB1iEmEgsLISZSJf3XFpraAYWejrChMiF196iclzDVwvv2nGej5cD7LHVW4vaQliueurm0MMqBbEWm5kYjpcsyax3C66ADUf+ZHn40snznXd92ahnXDlglhxedX1yx1i1futVbjvNFms4hZEJo4Y76+10E1oJBc13wfgT0peUwDuFUIoAP+fUuo3Nm9aa+fAZIsOMUIIIYSQDeDQ3CKG6wG2j1RHsl9uaEHsyJklq2vb5exiG//tnkdw6xUT+MZnzPa9n+mxBgAKYoQQMqhsWK6SEGKX8fQ1AHQvxocBfIcQoiGEuArANQA+DeA+ANcIIa4SQtQBfEe6LiEbihlluFwiiJ0xIhNNJ1UUGQ6xMLmZrYWdzAWVCVj2mKb+9LIbZ/Di66ay57779e3YHjdOBSVNx3SIteNUDLIjE59/YGc+d1cAc/SUWCXHpwlkfnPfFcRUel4aNfscAMmdWr1dFpkIhcXV5FyP1AMI5A63MBBo1gIstWOsdmKEhjMNxli1sg6xwBajtFOnp8jELkKC/qZXt/FsUS6PXexJEKuI9WvVQ+yeyL/lp+f9Lz9xN/7hx15UOuZNs+N4za2DZS6pBaKiQ6xPQawmu64D9CZSrZdDzOy065WqWMheoEPs0kQI8Z8AdAD8Yckqz1dK3QbglQB+WAhxV8k4AxU3vX9qhIIYIYQQQsgGcHhuCXu2DV3w54tLDf1ZuluP2C/d+0XMLa7i57/55jV9UXK0WcNIPcBxCmKEEDKQbGTRyC+mJe8PAngxgLcDgFLqCwD+FMDDAP4awA8rpaI0FuhtAP4GwCMA/jRdl5ANxRSGygSx0+cTh1jSGWZHJiojMhHIxSI9bFQiiJnjuDewfTf2tTilN4sVKhxiUSIkCYFY5WLT+FANv/29z8KOkXpBEHMdY0Auwuk56Xmtuh1iaWRiw+sQU7mIZTjEFlaSJLBWM4RIO8OAREgYqQdYXO1gtRMXOrDKIhN9DjHT1Vb1h2yvfU+To43scaVDzOoQQxYLWS/Z5vffdAd+/013AMgdYr75SinwiZ+8Gy+7cdraz85WA/t2jlTOfdCohbK8Q8yzuKoWq5GK0d2EoKAHsWstUYc+Qs/7caPJxNQeojnJxYEQ4o0AvgHAdym3iDJFKXUk/XkSwAcB3FGy3kDFTe+fbGFusY2nF9itQAghhBCynhw6vYi97A8rMDnaQChFpSD24OEz+INPfQWvf+4+3DQ7vuZ9TY81cZIdYoQQMpBcUGRiFUqp76l47RcA/IJn+T0A7tmoORHio5fIxKXUzWRGJCbb5s8zd1QqBul7l1rocSMTTaeZK8T47qFrN1hU4hCzO8RihFIikIlopudUDyVecM0k9k+1ioKYW3JmzB2w+7iKgljiMJMyEQLaToeYK4gppbIi29FmzeoQC6TAUD3E4moSmVgUxPxuK58jRwi/UOYiPdv6MF+vjkw0HhtxkWUdYi+4Jr85Xe8h1m8tcXyDRq0iMtH3TcYqsVKL0d3OR60HsSvMYgcv7Psi+n16gcP0hZSJAHyhcyeDgRDiFQD+I4AXKqUWS9YZASCVUufSxy8D8LObOM01c2CqBQB4/NR57Gg1uqxNCCGEENIfQogmgH8C0EBy7+vPlFLvTJOK/hjADgCfAfA9SqnVrZvp+qKUwuG5JTzn6v67ry51AikwM97E0TN+51YUK/znv3gIO0Ya+NGXXXtB+5oaa9AhRgghA8qGCWKEXCyYwtTSqr+HKY8ptNfvxEZkYs0fmRjFtmMsHzN/7Gorvpv/bWdcpWxXlymOrXRihEHi6DIjE02xpRMXXV4u5pja5aT37W4bKYWalAhcQSzOj0eLSL/3b1/BYyeSqKzRRmh1iNUCmTjEVjpYjeJS4csVU3zOHilEJkJViSBafOrHzVPlwrHnkPysB/KCO8SyfctyF9nFwsxYE1Oj/pvg/XeIBV3XAXoTEoMexdFu3HXtTjy1sFLqCjT5q//j+d7fv7VQC+RFLZRerggh/gjAiwDsFEIcBvBOAO9AcgPnY6lI/Eml1JuFELMA3quUehWAaQAfTF8PAbxfKfXXW3AIfaMFsYMnF3DHVdu3eDaEEEIIuQRZAXC3UmpBCFED8C9CiI8C+FEA/0sp9cdCiF8H8CYAv7aVE11Pzi61sbDSwZ5tQ91XvgyZnRjCkRKH2B/f91V87vBZ/L/ffgvGmrUL2s/MWBP3f2XugsYghBCyMVAQI5c95o3o5Y7fIaZ1oTh2HGKxyrq3GqEdFxg5ji437cp8VnSIeSITnejFWCmr48vsEFtu55GJSiUCGZCLLWEgsNIpd6z5CKSAEIlLzHWTKZXMT6Z9WWZkou0QS34ePLmQdce0mqHlogmkwHA9wGI7wko7LggKeWRid6EscbV1F5j6EUGG6wEWV6NKccvtEAOSY6+F6yWIbX4c33rz/h94dsH9p/EdetWh6t+9bqcjrOhny9YpieTsl1uv2IZbr9jW07o37157FIfLN986izukpPCzAAAgAElEQVT389ugFxtKqdd5Fv9WybpHAbwqffwEgK/dwKltGLPjQxiqBewRI4QQQsiGkMZN6z80aul/CsDdAL4zXf67AH4Gl5Agduh0IvbsYWSil9lxv1D19MIKfvGvv4jnXL0dr75l9oL3oyMTlVLsciOEkAGDghi57LE6xFbLBLE8ptDtECs4xLLIxHydZFt7THMc1+nju1+vO8LiOJ+L6RBbtTrEYoSGU0R3o2X9VKIoavkiE01MF1XkiX9UKhHEAimsuSiVb+sTkVqN0PoDsRYIDDdCKAXML3cysUOTR9r5O8Sk487yRSkWjq0PQWxHq47F00ul8YfFOSSPf+zl1+HGXWNdx+9JEEv3fTH/XT1a8Y27fh1i+ndvpe13eGry90L3/reL1WX1377lGVs9BUJ6QkqB/VMjOHiKghghhBBCNgYhRIAkFvEAgPcAeBzAmbTDHgAOA9i9RdPbEA7NJUnbe7fTIeZjdmIIxx88hihW1me+d330UZxf6eDnXn3zughY02NNrEYx5hbb2D5Sv+DxCCGErB8sGiGXPaYxqqxDTK8TxbkgBWjHWCqIaYeYG5kY+YUm05HlOn38HWKp88yIbzRFLNMhttqJUTM6v7TzLYtMlMIS05Jj8U4zQ2aCk/9YotQJVgsEVg2nnYLCztE6aoHAxHBRBGmlkYmaQCaRiQBwZnG1IKLpc1VwiHmEMmmcgypBxSemlbFjJIn5W+mUnzDzeuohv+vZV/bkGDKvUfl8k3XWK2Zv0PBdqqrz0Ug7xMocnppcEKtYR8cqXsxqIyEXCfsnW3icDjFCCCGEbBBKqUgpdQuAPQDuAHB9r9sKIX5QCHG/EOL+U6dObdgc15tDp7UgRoeYj9mJIXRihacWVrJl9z95Gv/7M4fxphdchWumR9dlP9NjTQDACfaIEULIwEFBjFz2WJGJJYJY3ttlRyZ2jAhF1yEWOw4xvX02pqGnuDf7feKN6zRTStmCmNUhFiEIRCYs6G40030UOXqOK5C5ZEKURxFLxLlk3qGUmZstmSfw4uum8C8/cTd2toqdUaPN0HLEhVJgqJ6YV88stQuxeln8onPOrkv/cJWWGJV3iFXF5EnRuwjykuunsnl3G8993AvZNarYTh9Lp0RsvdjxO8TK19cdYt0cYrVMbKyIu1ynDjFCSHcOTLZw5MwSzq90uq9MCCGEELJGlFJnAHwcwHMBTAgh9Ie5PQCOlGzzG0qp25VSt09OTm7STC+cw3NLGB+qXXAH1qXK7onEOad7xDpRjJ/+i4ewa7yJH7n7mnXbz8x4cu/jOAUxQggZOCiIkcseU1RaKrmhrsWiSClLQDOfD9VdQUxZP5PH+ZjKiB3spUNMO8BUiUPM7O1a6cSoSZmJKktOZGIgBCLHEtY1MjFzWhVfU0ohjhUCmazXjuwOMSEEpseaXqHDdYiFUlgOsTJBzOx4+uBb78Szr95RWC5FLn5Uub/6EUHedvcBfOztd+H6mfL4Q1Nv6ddo1JtDLHmt7aqalwi+90lVbIWO1ezqEOtBHL1qxwh2jNSxjbEWhGw4B6ZaAIAvP3V+i2dCCCGEkEsNIcSkEGIifTwE4OsAPIJEGPu2dLU3APjQ1sxwYzg0t4g92xiXWMZsKogdTQWx3/u3r+DR4+fw/3zDjRhprF+rzNRo4hA7SUGMEEIGDgpi5LLH1IF8DjGlVBaZGCs7YjGK4kygKkQmpgOXOsSMcdz7877b9doNFJkdYpZDLBdHltsRAjMyse2JTHQEsLL4Pe2wkhWiUazgRCbmczGHdTWNoVqAMJDW8jAQmbh4ZrFd6OrKRA0j9044kYuaxLHWPSZPv9aLICaE6BqjYI7Tb/54Lx1i+px0EzEvVtxD73ZZeu8Q6y6O3nlgJz7zn78OrXX8MEQI8aMFsYOMTSSEEELI+rMLwMeFEA8CuA/Ax5RSfwXgJwD8qBDiIIAdAH5rC+e47hw6vYi92xiXWMbsRCJUHT2zhBPzy3j3x76Eu66dxCtunlnX/UyNpQ6xsytd1iSEELLZ8I4fuezRQtBIPSgRxIx1Y9chlgtbjZLIRLNDzHKImR1ihcjE4jzdyMRih5gZmRgjDGTmtFlxHWJSwNVSysSVWiDRjqLMbeYXxBKHmBQCYSAzUVC/pnG1oVYaO2g7xGT2zaxOrFBP4/A0WvCyusKMcQMnrjBzf1V2iHUXofrB1yHWK/oaVYk2WgzsXKqCWA8RoibaIVbV6wbk75kqhxghZPO4cscIAikoiBFCCCFk3VFKPQjgVs/yJ5D0iV1yKKVweG4Jd6cx/6TIaLOG0WaIo2eW8QsfeQSrUYyf/aab+v4iazcaYYDtI3WcOEeHGCGEDBoUxMhljxZshhthFi3oex1IRCNTg4jiOHOCFTvEPA4x+MWxXgQA7QDTQppSyur9MkWolXaMWpCLQYXIRCksR5l7nCb1UGJxNaqMFYxVsr12ZFkOsYrjGk2FL3NpIAWGg1wEqzvWLm0YCx0nmLl9tlzmbqrK3iih4yDX549gKW1Rrh/08VaJNvq1S9ch1p8gdsOuxLH3NbvHK9cLg/L3MCFk86mHElfuGKYgRgghhBCyDpxaWMFKJ8YeOsQq2T0xhHu/cBxHzy7jR15yDfbtHNmQ/UyPNXHiLAUxQggZNBiZSC5bXvOrn8B1P/3RTFQYqQdYWvUJYuZjxyEW5683a05kosq30agyh1gPAkA7sjvJlOEQqwXCcYglApa+77/kRCZKIeDoYYXnGrfTyue00uJcIAXCoNghVnZcXodYIDBcz7X6htMhpoUwM0rRHDZwxKjc/eU/PiDv/Kpapx/kBTjEakbPWxn6GDuXbIeY87zLdXnmldvxDz/2Irzujr2V69V66GcjhGwu+ydbOHiKghghhBBCyIVy6HTSi7V3OzvEqpidGMLRs8vYu30Ib33R/g3bz/RYgw4xQggZQCiIkcuWz371DFY6cSZSDddDrHQSx9cnn3ga3/Nbn8K7PvqoJejESllCVhSbHWJpj1HHdnLZHWL5/qscYr4SMS1+aQ3E7BCrBdJyfMUKqEmZjbu0mjjGdAxA6OkQi0ocYrmIUDJX6MjEXICyRERDs3E31T1NpuARSomReu4QczvEtJgRmoKYccJCRxDTz6siCHuJVewHc5x+oxcaQQ+RielrbTrEMvbtHOl6rsMKlyMhZGs4MNXCk0+dt75IQQghhBBC+ufw3CIAsEOsC7pH7L98001Z0s9GMD3aZIcYIYQMIBTEyGVP5hBrJH8IPfn0ebz5Dz6Df37sKfzJfV91BDE4kYmmQyzZ/hMHn7K6xqLYjA80xTHTOWXPydshFtlRjK4g1o5scSQMRCbMnF1qW9GDUopC/1RcIq5oh5YWJbyRiXFyHgMJ1CrEBlewGE0dYubyUAoMGYJY3XWIeSIQTUHNFJICmcdGVkUQ5v1o6/NPojWffiMTwx4iE9NrealGJrqnbL2iLPV7hx1ihAwOByZb6MQKXz29uNVTIYQQQgi5qDk8lzjEGJlYzeufuw8//8034+7rpzd0P9PjTTx9foVf/CKEkAGDghi57NEC00jqVrrn88dwZrGNO/Zth4IrgLmRiXH2fHqsgW+/fS8+9MBR/MvBpzKxwowyjEscYr1EJurYQ5UJYrkg4opGQCIG3XblNkgB/O0jJ6x1AlnsDCsTV9yYOX+HmB2Z6L5mYh7aaLMGwBYA3chE99j0/muOEyzb3lpuCGg9RBCuV2Ri4MyhH/TxVjnErptOOrOuTX9earjv//XqNw4lIxMJGTQOTLUAgD1ihBBCCCEXyKHTi9jZqltfMCVFrp0exXc/58oN38/0WANKAU8t0CVGCCGDBAUxctmjdaDh9I/Gc8sdAMCe7UNY7cSFyES9figFolQIAhIB443P2wcAOL/SyeIR7Q4xeyyNK374BLHFtN9M708plbm86h4lpxZIXDs9iu973lUAgJffNJO9FkrZe2RiKKw5+TvEEodZEplovz452vAe2827x/BDd11dON5QSmsMLVRq9P5D0/Fm7FI6cYVaBOklMrFqnX6wO8T6G1PHSA5VRDe8+Pop/M3/dRe+9bbda5vggLOWyMReyN2FFMQIGRT2UxAjhBBCCFkXDs0t0h02QMyMJdGMx8+yR4wQQgaJsPsqhFzaaGFKu5IWVhJBbKgWJB1jsb2uUgpS5LGDWuQy+6oilTvJzGhCU4My9Sf3Br17/7/VCLGUCmJxJrTlcYxlDjEA+KlX3YC3vGg/drRyYUqKYoeYKhPEenSIxSoRxEzx4gfvuhrf/4KrvOO+9IZpXJM6nMxt3PFfcGDSe1xmt5gVuWgsDwyBrsohViX2rQXzGPod8urJFt73xtvxgmsmK9e7bubSdIcBvUWIrgX9XmZkIiGDQ6sRYmasiccpiBFCCCGEXBCH55bwjD0TWz0NkjKdCmIn5ukQI4SQQYIOMXLZo7uztDNHO7GGagGiWKFtdIDFMTLhJ5Qi6QpLX9YiGaCjFZE9zrAiE/MnrhDjdm21GmE2rzwysZtDLHc9mWIYkEQDFhxiJbHWukMsc1F5FB7dZ2Z2dgHAtz1zD6ZGm4V1AVuUMId0xb1nX73deu7rgTJnZLmzZH4egqBcBKkS+9bChTjEAODu66cz8eZyxH3/r9d1ya/z5XtuCRlEDky1cPAUBTFCCCGEkLUSxQpHzyxhz7ahrZ4KSckFMTrECCFkkOBdQXJJ85Wnz+Pkueo/PqLMIZZE1J3XDrH0uXZm6XVjlYgcgUgcYrHPIWYstzvEzPjEfA6uZuLe/281Qyy1I0uA0x1iUvgFg7Dipn8gZSEisSwyUTvn9D58brRYwTov2XF5xtO7sSMP8zW1uHf7ldvw0huKwlDg6YEq6xATIukj+4+vuA6vvHmX9/jMsdYrms+KcOS/sn3jvp1dgWyt1DJBbF2GI4SsEwemWnj85EKpU5kQQgghhFRzfH4Z7UhhLyMTB4YdI3WEUlAQI4SQAYORieSS5oX/4x8AAE++6+tL19H330Ych1gz7XBabueCWJwKXUIkjqPYcIKZcYGmIGYKTeatPssh5kYmOnPU7rXlTmR1iLUjVejc0lTFwvkcYnHsvxGpu6y00DU+VCuskzvE3LjA8jmElqCVL9eC25+95U7/3IXtxku290cu6jm/9UUHSucBJNdaivw8XyhCCEiRi4SkP9z383olHIZZ/CcVMUIGif1TLZxfjXB8fhm7xvmtZkIIIYSQfjl8ehEAsHc7/5YaFKQUmBpt4DgFMUIIGSgoiJHLHi0MaeFncTVxiOWCmBGZqBSU4xDLOsQMMShW/shEVSKOFQUA+/loMxfrYiMyMYpjBFJ4BYOwKiLQ0yHmPtdop5yeY6kgphSkE5lYJWT4HF5lbjd7O5kesz9yscw5VsX4UA0feMuduGHXWE/r90IgBeJIrZu76XLCvW7rJSr64jYJIVvPgckWAODgyQUKYoQQQggha+DQ3BIA0CE2YEyNNXGSHWKEEDJQUBAjlz1aYKqlzqR2ZEcoLnfMyMTESaWFm8hxiOkb7WaUYscQmkzNyXSIuTf8fR1iQBLfqDeL42TsMBCWW0oTVuTC6fXjOBGx/vXxp/DzH3nYu+6rvmYG1063sizyiWGPIBYnYwVClDq3CvMz55w+9MUx+raTQlguulJBrA8j0K1XbOt95R5Ijl2tm7vpcqIYIbpekYlyXccjhKwPB6ZyQewF10xu8WwIIYQQQi4+Dp1ehBDArolm95XJpjE91sDjp85v9TQIIYQYMDeKXPZkgliqXLSjxBHWrCW/HmZkokqdX0IIQxDTHWK50BTFKhOuojh3mCmYbrF8Dt0i4sw4R+3k0jGFobR7uzRVLhhTuAOAe79wAnOLbe+602NN/OBd+zORzucQS86LKnSIVQkPZmydXq/eQ7lTEIiCQ6wsMnErhY/c9UbxpV8KDrF1+j+Vfm9UuScJIZvPzlYdY80QB08ubPVUCCGEEEIuSg7PLWFmrIlGGGz1VIjBzFiTHWKEEDJgUBAjlwVmVKGL1qu0o0qLRM30D8mlVcMhZnaIOYKYMMQg7TJLtjHnYezX7BArOMTsObYyQayTbadUMtdASq/oElaoCJlDLB3r/EqndN2G49ryCWJRKhS6kYlVWpCvQ6xXh1gghDW2efzhgAhi+jzQIdY/GxWZWEuFsG6xnISQzUUIgQNTLQpihBBCCCFr5NDcIuMSB5CpsSbOLXeyag5CCCFbDwUxclmw4Ag+ncjuBQPym+WdKIYUQEM7xDrmuom4puMRI2U6xAQCYwyN5RAzBDHzcbeION0hZkUmKoUoShxiPu2rW4dYMrdUEKv446we2N8w8wpi6TiBKO/2KszBI1z14hD7mt3jePbV2x2HGIzHplus63Abhp4TO8T6x9Wr1q9DLHlD+ByVhJCt5cBUC4+foiBGCCGEELIWDp9exJ7t7GIdNGbGkgjLE+wRI4SQgWHDbhcLIf5ECPFA+t+TQogH0uX7hBBLxmu/bmzzTCHE54UQB4UQvyx4J5msE3Pn7ThA28GlBbG8Q0wKkQlBy4ZDLE47w3Q8YidWmcNMChgOsVwEszvE/I+LkYn+DjE3MjFxiAmv46UqMjFwIhMXVqLSdV3X1sRwvbCOPp+BtEWoyg6xwBTOkse1Hhxi/+H2vXjvG55liYDmPxW+cbeC3CHGf8b6xb1u63UK9e8EHWKEDB4Hplp4amEVZxZXt3oqhBBCCCEXFaudGMfml7GHDrGBYzoTxBibSAghg8KGCWJKqW9XSt2ilLoFwAcA/Lnx8uP6NaXUm43lvwbgBwBck/73io2aH7l0UErhV/7+MZys+APjtHODbdVwfa2m4lXeqxVDSpEJQcsdQxAzurJCKVKBzHCIpWOsegQ3ADCDG6s6xFDWIdaOrMjEKI4RBsIfmVhhj9L7i+PukYmuIOZziGlHnBuZWCmIWR1iyc9aH5YuAVP4ypf32mG20TAyce1snEOMHWKEDCoHploAQJcYIYQQQkifHDu7BKWAvdvoEBs0ZsYbACiIEULIILHhgWKpy+u1AP6oy3q7AIwppT6pksKn3wPwzRs9vzLaUYwvP3XeEk7IxlDV79ULJ+ZX8Ev3fgn3PnyidJ05RxBbiXKRS7ubbIdY3p1ldYilXVkijQbsxCoTtnSvGOBGJhqCWIlDrFtnUh6Z2EFsRCa2U4eYv0Osu0Ms6qFDrOgQKwpi7ZLIxCoxyCecVc3ZpaxDzBx3K6PxtMuJDrH+Kf4+rM+4U6NNBFJgYqjociRkKxFCvE8IcVII8ZCxbLsQ4mNCiMfSn9tKtn1Dus5jQog3bN6s15cDk6MAwB4xQgghhJA+OXR6CQCwdzsdYoPGFB1ihBAycGxGw84LAJxQSj1mLLtKCPFZIcQ/CiFekC7bDeCwsc7hdNmW8Jv//ARe/Ev/gO9+76e2agqXBYfnFnHVO+7Bx794cs1jdNLMQlN4cpk7bwtiZmSijjfUrpF2FCMQhkOsnTvI4lilHWLJ+qZDLJAiE2DMmERbEIP3cTEy0Z6/GZmoRbVYIesQ80YmVnWIOQ4xt2PNxO31quwQc+ZSFVkYyqJw1o9zp0x4s/ff83Drjn4vUA/rn24C8Vq5c/8O/OtP3o2Z8ea6jEfIOvI7KLrifxLA3ymlrgHwd+lzCyHEdgDvBPBsAHcAeGeZcDbo7N42hHooKYgRQgghhPTJoblFAMAeOsQGjtFGiOF6gONn2SFGCCGDwgUJYkKIvxVCPOT579XGaq+D7Q47BuAKpdStAH4UwPuFEGN97vcHhRD3CyHuP3Xq1IUcQilHzyTfsDmS/iQbw5/edwgAcM+Dx7JlCysdnDpX/GNhfrldWAYg6/Aye7s0WnQ5fb48MjETxNIIv47uEHMiE8NAIFbIIhOD1CGm9S4pBKSOTOz4O8RMEcx2iNnzdgWAEbNDLBPEkg6xUMpsfXOcSoeYI9xVOcRqjkhVJYgJ4UYmlg6LwNP1ZcYodsM8R6LMIbaFeYXsEFs77ttgvc6hECLLcCdkkFBK/ROA087iVwP43fTx78Lvmn85gI8ppU4rpeYAfAwXadx0IAWu3jlCQYwQQgghpE8Ozy0ilAK7ximIDRr6M+iJc3SIEULIoHBBgphS6qVKqZs9/30IAIQQIYBvAfAnxjYrSqmn08efAfA4gGsBHAGwxxh+T7rMt9/fUErdrpS6fXJy8kIOoZRzy4lAEF9gnB8pRymFv0yFsGYtyJa/7N3/iGf9wt9a63780ZN4xs/ci08+8XRhHC0Q+RxiWkg6s2iLaVaHWPpYCz9Zh1hgRybWpESUCmAyjUfUnWJA7gQKpchca+68YisyMZ+Pe8Pfvf0/VAsgRTIXvZ3dIZYsMwWgRhigDC3cRZkgFpWu67q8zGvlEgg7prB3h9iFRSZaHWI9dphtNFrUoSDWPwWH2GZ4mQkZPKaVUvrbIscBTHvW2Q3gkPF8S931F8qBqRYOskOMEEIIIaQvDp1ewuzE0JZ+IZSUMzXawImzFMQIIWRQ2OjbjC8F8KhSKotCFEJMCiGC9PHVAK4B8ER602deCPGctHfs9QA+tMHzK4WC2Maz0kl62gDgmPHHwVHjcTuK8epf+Rf84t98EQDwwKEzhXGiVHzqVEQmupGApptMxyeGbodYTUcm5g4xlQpg2gnViVQWYZi5tKRAu1MSmWjMwewTc/9wdYWkQAoM10MnMjFxiJkxheZ2r7h5pvR8aOEpVgqrnRirHnfdWnAjE3vvEEvn1VdkovnY7wrbys8Dgce1R3pjoyITCblYSbtVL+gPks1w118oB6ZaODy3lP1/lxBCCCGEdOfR4/O4aufIVk+DlDAzTocYIYQMEhstiH0H7LhEALgLwINCiAcA/BmANyuldEzQWwG8F8BBJM6xj27w/EqZX0ocRRUaC7lATJHq+Lw/mvLE/DI+d/gsHjk2D8B2H2m0ltOJihcrNsQjkxVPZKIZDRhIgUaQOKH0jblASkRKQanEsRJIgUjZkYl6jqbgVu4QMyITu3SISSEwXA+w1O5k48VKIYqTDjG9fSAE3v3ar8W9b7+rMhpOi0adWFXGJZZx8BdeiZ961fWF5dKYC9DNISaN9ZKftaD3f5LMsa0OMXP5FqpR0iNSkt5wTxnPIblMOSGE2AUA6U9f2eYRAHuN51vqrr9QDky1oBTwxKnzWz0VQgghhJCLgrnzq/jSiQXccdX2rZ4KKWF6rIkT8yvWl6IJIYRsHeFGDq6UeqNn2QcAfKBk/fsB3LyRc+qVzCFGRWzDWEjPcSOUpQWjsWNc8t0X1wJRx10ZeWeX6x6zOr4yQcwUaIwOsXYumHXixBEmU4dYux1nwlbmcpICbWN/5rzMv3/MGblCny8ybrgeYHE1yvanFDKHmHZ8BVLgW27bg27o8eNYFdxzvRAGEoEnxy5Iu9Xy/VSNcWGRiVIUtwcGKDKRDrE1U3SIbdFECNlaPgzgDQDelf70ueb/BsB/FUJsS5+/DMA7Nmd668+BqRYA4OCpBdw421e9LCGEEELIZcn9X5kDADxrHwWxQWV6rInVTowzi21sG6lv9XQIIeSyh80sJZxb1g4xCmIbhRZiDky18NTCiiVSAUmkYOScf5/Aoa+RLzIxc4g5r5kOrlUdmWjcdQ9MQayjHWICcdYhJhLHWKwyQU67WKQUmcgGuN1mhkPMWF7oEHMOMxACzZoWxPSxIXWISQzXA+92ZehjPXVuBf/pLx7qbSMHn0jhOsSqBKnQ4yQL+3CImfu3+8TyTrWBiEykmtM37inzOUMJuZQQQvwRgH8DcJ0Q4rAQ4k1IhLCvE0I8hiSC+l3purcLId4LAKnD/ucA3Jf+97OG6/6iY9+OEUgBHDzJHjFCCCGEkF749JefRj2QeMae8a2eCilheqwBAIxNJISQAWFDHWIXM3mH2BZP5BLmvCGIfeHoPE7ML2Pv9uHs9U6sLOEK8AscmUPM04NVJpateiMTczFGd2GFUmBpNcpeP686aYcYEIhk31qzsxxipZGJ+RxMrc81W7kRcVIKNEKJdhRnNnulFDpRjKARYqgWZvPuBS3S/MrHD+JfH3+6p20KY3hECllwiJXPx9sh1od4ZIlgsLcLpcRqFG+tQ0zSIbZW2CFGLjeUUq8reeklnnXvB/D9xvP3AXjfBk1tU2nWAuzdPozHKYgRQgghhPTEp5+cw9fuHUezFmz1VEgJM2mdxfGzy7h+hikIhBCy1dAh5iGOFRZWtSBGRWyjyBxik0lE0vH5ZStTeaUTY6XtCGIedSGqdIilP11BLCoKYmaEn77/Xg9l1iEWSpEJYKZDLI9MzB1Bq1F3Ecx8bxUjE+E8F6gFiSBmdoh10g6xkUZgzaEben/aWbYWfEJPIJP/NFXTMTvE5BocYmUdYkAuMG6lO0sfCvuv+qfYIbY18yCEbD4HJlt0iBFCCCGE9MD5lQ6+cOQs+8MGHN3vfnLeXxVCCCFkc6Eg5mFhtZMJF+wQW1+WViMcPbMEIBfEdm8bApDEVJ5P3VgAsNKOsBpF1vY+cSHOHGLFa6VKxLK2TxCTtkMM0IKYFswkYpUIUVIkgkeURigCuagTCIF2p+hWA2wRzOoQc4QbX2RiPZRod1QxMjEQGEqFrbL9ugSp+BddwPvbdy2ksCMTq4QMn0Ostg4dYkB+Lbcyai+LTKSa0zdCCOu9w3NIyOXDgakWvvzUea/rmxBCCCGE5Hz2q2fQiRX7wwacqTQy8fg8IxMJIWQQoCDmYX4p6Q8bH6oxMnGdueO//i3ufNffA8gFsfGhGgAgivPuNqDEIVYVmVjhEHOFnxUrMjF5rR4UHUv1QGYdYrVAIFYqFcQEQikRKcMhlm4eSIFO7L+RV+YQc51Mhcg4mUQ2rhqRiblDTGI4jUfQc+2GFmtOL7a7rFmOT6QIZO+Rib4OsV4jH5Ox88cFAXEA4gqzTjlqOWvCEjz5fypCLhv2T3T1TJUAACAASURBVLWwGsU4PLe01VMhhBBCCBloPv3kaUgBPPPKbVs9FVJBIwwwO95kCgIhhAwIvM3oQfeHJYIYFbH14pNPPJ2dWyDvEBvLBDFlvb7SiS3hCvALLFlkYkWHmCuI+TrEgqDoWGrUZNYhFqSRibFKxA6ZRSjakYmBFJnIVjaf5HH5cfmeZ5GJWYdYclyBFBhuhOmx9PZ+1YLR3PnVntb34Y1MFMJxfvXWIabpKzIRRUHNHXsr4wpzUY6K2Fow3x48h4RcPhyYSmKUecOAEEIIIaSa+758GjfOjmG0WdvqqZAu3Dg7ji8cPbvV0yCEEAIKYl4oiG0Mn/7yaev5wnIHQgCjzUTMSQQx0yEWYcVxPPlEGG3G0g6xf/zSKfzonzwApVTmyOolMjEQIhvfcoilHWI1KaFUEsMoRd4pVohMlMIavwxV0SHmczzVw2RcfbyJQyxGKEXfXWBarDl9fhVX7hjG77/pjr62B/wihZSuIFa+fc0Qv7RgGa7BIebvMuvfcbbe6GtKLWdtVEViEkIuXfanvaIHT1EQI4QQQggpY7UT47OH5hiXeJFw0+wYnnjqPBZXO91XJoQQsqFQEPOgRZmJYUYmridZtGB6b3thJcJIPcxEkEgpzJsOsXbRIeZz/EROT9gb3vdp/Plnj1gimCtsrnoiE4WwRS0AqIcBlju6Q0ykEYlpV5bQgph9XFWCmDkN87EbCWe6n5KxtUMs31+sFKIocYiN1EPv/srQx7ew0sHMWBMvuGayr+2TOfs7xEwRqsqhZa6X9bgFvQsfeSShJ7pxAOIK9TWlmLM2bEFsCydCCNlUxodqmBxt0CFGCCGEEFLB54+cxXI7xh0UxC4Kbpodg1LAI8fObfVUCCHksoeCmAftEBujQ2xdiWMt5CSOoIWVNlqNEEGqHMRrjEzU47qRiQvGWK5DzBuZKEUm8mixpR7KbN0wkEaHWOJm6sRxJppmPVhCoNNTZKLhECt0iNnbBTIRxFY7cSakxQpoxwphIDDUp0PMPI+6w61f/M6s3gUg0w2mr0+tj8hE181nz4ORiRc7jEwk5PLlwGSLghghhBBCSAX3PZkk8NxOQeyi4MbZMQDAw4xNJISQLYeCmId57RAbqmUReaQ/3vPxg/jIg8esZZFxHttRjPMrEUYaQebm6XgjEx2HmGdfOm5Piyr6Rvq8MVYU2+P4IhOlENlctC7TCPNfkVCKrLcr7xDLIxQ1UgqsljnEjMemRudGJkon8k+KRCxatTrEVNYh1q9DzBSjqgSxKh3CG5noOMSqMDvbOoYo2Su5eOkZewAiE/X5oZazNsz30lYKm4SQzeea6UQQi2nTJ4QQQgjxct+XT+PqyRFMjja2eiqkB3ZPDGF8qIYvHJ3f6qkQQshlDwUxD8/atx3v/MYbsW24DgCMTVwD7//UV3HPQ7YgZp7HdhTj3EoHrWYti5YrOMTaMVbakTNG8WJ0HIeYdhmZY0XORVwxBbFOLqS5riNXENNj5R1icfpcWOt1c4i5Iqt7w18/zQQxKVAP0g4xlTvtOlGMUMq+HWJBj4JYzc1y9MzRHdcV98owRTkdW9mPQ0xv7dtdaAiJW4V+TzDub20IMRjRl4SQzedr90xgYaWDL51kpAwhhBBCiEscK9z35GnGJV5ECCFw0+wYBTFCCBkAKIh5uGHXGL73eVehWUuj/OgQ65uVToyVtu2SMr/p3Y4Uzq900GoECFPRpegQiwtOK/davOfjB/EPXzyZbQ8A9VRUmV8yHWLJa48cS/74MCMTV6MYQiBzfQHFLjEg77fqRCpzr3TivFNMI9MoRR9m3KGJ62TSHWKZY013iFmRiYlDLJQCI421RyaOpYLYnm1DhflUdXqVdXf5usV8mMesr0+tD+WjqkPMvY5bAd1NF4aUYiCcfoSQzUeXw9/35NwWz4QQQgghZPD44olzmF/uZH8zkYuDm2bH8MXj50o75wkhhGwOFMQq0DeyKYj1z0o7qhSz2lGMheUOWo3w/2fvzcPkuOtr7/Otqu6efdOMltFuS7JseffIGGwDXsAGAzYEg7kJW+ByCYSQAEm478sNuYTcQHIDCZiw3MuWewOGsPplB2O8QWwJb8irZFvWbu2j0WzdXfV7/6j6Vf2quqq7Z+0Zzfk8zzzTXeu3ukeecZ0+54QOMVepmFA1XnYrRbXEW/Hle3bi1of2AUDoysoFrq4TiQ6xh/ccx8v++S5s2zuI0WLkPCu5nhGVGHekmC4mLdyVPA+WCPKOhZLrQSkVcynZEhfcTFSGQ6wiMjFxfksEOcdCyVWheKSCDjHbFrTkJhaZmOYQ+9mfvRA/eM9lsfXVhIgsIapek5djuM9KgYBoVxHgKs+fPYczBwQxq4pgR2pjicyJ95EQMvus7GnG4vYCtgbdGIQQQgghJEL3h128loLYfGJTfyeKroenDrErlxBCGsnE7qIvMPRNWOph9fP9B/fi2SMjGCu7FXGHpj5WLHs4OV5Ga8EJhRHPU6HLCwhcZglhKRl96BkiWugyCkQVs0PM8xQGA8fY4Ggptq7kepEjrEIYq3SIuZ5C3vbjFIvltMhEK4wATKKXJoW9ZDJhKKaEkYlGh5ixsx+ZKNMSmdiSd9DTmg/O76+rFmGotxGJ/o1YInWLF6bWFoqZVSIaK/fP7uiaC3GF+qWjuWlyWFK9J44QcuoiIti8pgdb6RAjhBBCCKng3meOYllnUyzlhcx9NvV3AAAe2XsCG5d2NHgaQghZuNAhVgV9IzspwswmD+4+jr//yeMNO/9Eee8tD+ITP38SJVdViFlJh9h42UVTzg5FqLKnYt1b4yUX4+W4qJZ0VpVdLxTRtMsorUNMRxsC/vt5YrQc9oOVXBUKUskYPjMyUIs1pSAyMW9b8FTgMDNUD8tCpgXejDs0qYhMTDjEbPE7xPzzR8f2FGBbFvLOxP4pm+frDkQwILpunfjoVFFz9GtlbmNbcedXNcwoQf1vbCLReHr3tD30+9bIqL00UZXUj4jwNSRkATOwpht7j49i7/HRRo9CCCGEEDJnUEphyzNHsXlND+P55xmn9bWhKWexR4wQQhoMBbEq6JuxjYxM/NkjB/Avv3qqoaLcZNHOrZ2Hh3HtP92JQ0Pj4bqS6wtUfueUv0w7xNoKvnFxvOxVRA8mXwfzuX6sxaFkh5juMHM9hRNjJXS35INZDIdY6OrRz6N/IpFDzINlRecZK3nxyMSgWywNT0VxhybJG/76D9ucbUEEYUSjf764SFhNtMrCjGh8nhGzoA/V3uS/B6+5cEX2MVJiFf1utQmPE4p8uQlFJsZddGnrGvk/CFLFwUZqY0llhCkhZOGgOzEYm0gIIYQQErHr6AgODo1jM+MS5x22Jdi4tAOP7Bts9CiEELKgYWRiFaIOscbNoAWhsZKL1sL8eru0u+vm23fg8QND2HEwykkuuTpqMHIU+Q4xD815GyfHy+mRiYn3wo25zuKxe6ZDzPWi7i3fIVZCd2seB06MVY1MjHeIBU62wCGmHWZjZTcmaNlVHFJ6XIX4hSQFMX3aGwdWYN3iNliWhM635GsyGRdUd6sfk/ih685EUy6KW9Q/8x3NOdzxF1egJZcdxRj1nFkAvHCWybh59HvjTEBN06fJ6hBrtIiif5bobpoctkjo/ksTPQkhpzYbl7ajreBg685juP785Y0ehxBCCCFkTnDfM/6HhZ5HQWxesqm/A7c+tC/oouf/5xJCSCOgQ6wK+h6s10BFTDtnkq6g+YAWbp47MQYA6G0rhOuKrgdPKViW4RBTvmhVcCw4lmC87FaIP8nIxLhDzAuPA8Q7xFxPhcvLnsKJsTK6W3xRyI9A9LdLdhbFO8Qi4U5EkHd8sWi06MbEl2omJz1/8kcqKWrp8y7vag5vBGYJYpNxiLU35fD0/3g53n75aYnz+t9FgLaCU1WIsBLioV42GYHumrOXAgAGVnfXvU+1njDLmtwc0wnj/qYGIxMJWdg4toULVnWFpfGEEEIIIcQXxLpacljX19boUcgk2NTfiaGxMnYfZSw4IYQ0CgpiVQj7lBoYmVjUglg5vZNqLpHs+yomBDGz56pU9uB5vtNKO8TcIDIxZ1soOBbGSx6KiWMmIxPNaELdP6ZfsyFTEFORIBY6xHRkYtkLhZ+kyBNziNnaIebBEhgOMS/hEMu+ea+nregQS0YmBt/N4+Yz3FOTFX6qRg3WsX+y50zPMhk3zxVnLMbOj12H9Uva696nWiyiY0nDP21VTbAjtbGs6N8cX0NCFiab1/TgieeGMGhEIBNCCCGELGS27DyKgdU9TNGYp5zV3wEAjE0khJAGQkGsCvoPjFoGsQ9/fxs+8bMnZmQG7QYaLc59h9jR4WLsuZ79wKAviJXdSNQLO8SMaLuyp1D2PNiWoJCzUyMTzffC81Ssi0uLY1qIOzEaRSaWXQV9+uHxMsqeQlfgECu6XkVUYiiMGXavnBHtGOv0Krox8aWaQBV2iCX0zWTKYvjHrXGonJN+XO0cW9XTgnWLp/YpMWsCMX9pHV6WSIW4N1NI5UsUYluzN0cWWr9stDA3XzF/lugQI2RhMrCmG0oB9+861uhRCCGEEEIazsETY9h5ZIRxifOYjUvbYVuCR/adaPQohBCyYJlfpVSzjL7Pn4zpS/LV3zwLAHjfS8+Y9hl0L9Z8iEw8cjIpiPkznwi6vIqu2fflwVUKIr5gYIkvcJVdBcfy+7nGyy7GS0lBzIhITLwvWnDTItrQeCm2n9732Ig/Z+gQc71QtAijExOdYkAkdJWD7rN8rEMMFdulUW+HWFpkY66GQ+zOv7gi87z1Ilb6PGnobeIOsck71iZK8r0yMYXWRhGJq42dY75iiRgRpnwRCVmInL+yC44l2LrzKK44Y3GjxyGEEEIIaSj3BVHSmymIzVuacjZO72ulQ4wQQhoIHWJV0Dfak8JLvfzzL7ZjzQd/OKUZdGRgMo5wLpJ0iBXLHr712z3h87IXiVtF14NSyhBVrMAhpuDYWhDzKq473hkWf19KGQ4x2xKUjQ6xo1oQa/UFMd+p5h8jGXNniju5wC2mBTQdmeh3iJmiUPY/qygyMb48KSIJKqMLTUHM3HwyHWJZRDGE9Wzrf092iM2WmycpYpo41uzNkYXQ3TQlRKKfbYqKhCxMWvIONi3vxJZn6BAjhBBCCNnyzFE052xsCmL3yPxkU38nHWKEENJAKIhVQbuDakUmZvHJXzwJoFK4mQha3Bkrzf0OsaQg5ingA//+UPi8VDYjEz24nooi0SzfxVX2FGzLQsGx/Q4xN9shVk68rm5CENMdYjlb4HoqXH982F/eHUQmApXdYWkdYrbRdWY6xEZLCYdYlZv3ev5kh1hSNAndT8a/ULNDzDFWTKcjK0xqrEPE0duYQp1tySw6xLLdQ6a7qFEw7m9qmOLqbP1MEULmHptXd+PBPcfnxQeDCCGEEEJmkvt2HsNFq7sz02PI/GBTfwcODo3j0NB4o0chhJAFCX+LVkHfx/amIGgBU3N36cjE+dAhdiQhiCUpBUIS4AtinooEGMeyAtHKQ84SFHIZkYnVHGKuB89ToYimoxpzwbH15kmHGFDZnZV2I147xMqu72wrODYAX6w0RZmqQkwww+BoKbY4ecM/FHtgnj9dBHOqKXATJOmQq75t5SyWCGbrb3N91jS9ybHnTmSi8L+yk8KSyk4/QsjCY2BND4plD9v2MlaGEEIIIQuXwdESHj9wApvXMC5xvnNW4PB7dD9dYoQQ0gimfKtWRG4UkUdExBORgcS6/yoiO0TkCRG5xlh+bbBsh4h80Fi+VkTuDZZ/Q0TyaCD6JuwkExNDAWUq7q7QITYBUe3ocDHcbzY5Opz+6ZYNS9oA+IJVU84XkfR8lhGJ5noKJVfBtgRNjh1EJiYdYtHjpCDmGmKYud4JHGJaTDs2HO8Q8+fwv4c34K1KQUy7xcqeFwhiQYdYyU3dLg1PKfxk235c9Y93xJYnd9H3/00dIGeni2DVIhonSlp3WRbpLjqpOc90xTskxcvkuka7iqrNR2pz3Tn9uPrMJQDqi/AkhJyaDKzpBgBs2cnYREIIIYQsXH777FEoBWxe293oUcgU2bSsEwDYI0YIIQ1iOu6kbwPwGgB3mgtF5CwANwHYBOBaAP8iIraI2AA+A+BlAM4C8IZgWwD4OIBPKqXWATgG4G3TMN+k0ff1q3WIVXOPaUfPWGny7i4t8ExEVLvwb36OP/7a/ZM+52RJurk0r9+8CoAvLGpBTF+P6cTSsYY520IhZ2G05FZ2iMUiE+PnK7uqImIR8N8H11Phvse0QywlMjGMKgyda6YI5b+fnvJv0JuCWCwysYoQoxTw8Z88YZzXP1Yy9k8/N5fnHDMysT4BbqJMpENMUlx0lkgYFZjFD95zGZ7+Hy+f/JDh+fU5K9c5ltQV+ziTRL10DR1j3vLeq9fjpotXAqCoSBYuInKGiDxofJ0QkT9NbPNiERk0tvmrRs07E/S2FXBabyu2BiXyhBBCCCH1ICIrReR2EXk0+BD3e4PlPSLycxHZHnyfFwrTfc8cQ84WXLByXoxLqtDZksOK7mb2iBFCSIOYsiCmlHpMKfVEyqrrAdyilBpXSj0DYAeAi4OvHUqpp5VSRQC3ALhe/LvXVwL4VrD/VwHcMNX5poK+CZvsezKp5tzSgljS5TQRog6x+kQ1Fcz6s0efm/Q5J0uWcNje5ISPmxz9mvjXE3V2WXCVQtn1YFuClryN0aJb4XSrFplY9rxUUU4LYvp9HBz1oxQ7myNBLOoyk9hz0+1kOrQskbBDrOyp2A37tJv3+jqHi2U8c3g4XO5YVqqAlBTmgHiHmDnXzAhitY+pT3vR6ugPcsuK956lIdPU7xW5C1NeP6vxkYl0iE2daqInIQsBpdQTSqnzlVLnA7gIwAiA76ZsepfeTin1kdmdcuYZWNONrc8em3KENSGEEEIWFGUA71dKnQXgEgDvDj6M/UEAtyml1gO4LXg+59my8yjOWd6J5rzd6FHINLCpvwOPUhAjhJCGMJPtNssB7Dae7wmWZS1fBOC4UqqcWF6BiLxDRLaKyNZDhw5N++CaKDIx+wZMtW6v6XWI1XeMtHtFI8Uynj50ctIz1EvWjaqOpkh4SjrE9A1v2wJcV6HsKTiWoDXvYLhYrnDGmeJkUhDzVPQ6meJRzhaUPS+cbzzYRs8SmyMpjBn/QkwRyhKEgpi5P5AuUOnj7jk2Gl9upYtDaR1i+SyH2LR2iMW/V9/W32hJRxOaclYwlzVrUYX6NGl606qeFqzsbpmVObLQ7yv1sMlDUZGQGFcBeEop9WyjB5ltBtb04PhICU/Nwt8yhBBCCDk1UErtV0rdHzweAvAY/HtM18P/ADYwBz6IXQ9jJRcP7zmOzWvZH3aqsKm/E88cHsbJ8XLtjQkhhEwrdQliIvILEdmW8nX9TA+YhlLqC0qpAaXUQF9f34ydR9+ETUnhCxmtIlTlA6FiKg6x0gQFsVLKsO/52gO48h/vQLnahUwDrlKpN/87DIdYPukQE91D5TvEXE/BsQXNeRtDY2WMJvq5zEtICmJA9H5ogQbwhUlPRdvr9yPuuIrfeNenrOYQKzh27Hn4OEUQ0vGKJ8ZKseWOlR4xmCZM5VLmTc44VWQCAoQpVvzqA1fgw688Cz2t+ZqRidOFFgvT3GzvvWo9/v2dz5+VObKwKeZMGf3KTYejkJBTgJsAfD1j3fNF5CER+bGIbJrNoWaDi4PyePaIEUIIIWQyiMgaABcAuBfAEqXU/mDVAQBLGjRW3Tyw6zhKrgr/JiLzH92t/th+usQIIWS2qetOulLqaqXU2Slf36+y214AK43nK4JlWcuPAOgSESexvGFo/aFqZGIVoSrnTINDrDyxDrE0kejeZ/zejaGxmf3kiaeAtrxTsbzDiCYsZHSIWZY/e8n14FgWWgsOjo/44lGXsb8X6xCrvNbh4NM1ZoyA7v4quf72RdeDEzizoki2aA4gEpycmPAUPRYjMtHcH0BMENL7FwKBLvketBTs9MiDlC4vU5AzXWHTGZkIBL1mdWxnxtkt7WzCWy9d6z+fZYdY2ulEGt8hVi3SkdRHUqAmZKEiInkArwLw7ymr7wewWil1HoBPA/hexjFmxV0/E6xe1ILetgJ7xAghhBAyYUSkDcC3AfypUiqmPig/Dij1hs9c+ttpy86jEAEGVlMQO1U4KxDEHtk72OBJCCFk4TGTkYm3ArhJRAoishbAegD3AdgCYL2IrA1u8NwE4NbgD5HbAbw22P/NAKoJbjOOvqFeTRAbLWYLVVqomIogNlGHWJpI1FbwRarjo6WKdVOl5Hr41G3bMVZy4XkKzXm7wiVmdojZ4gs72iFmdna5XuQQazFEoq6WdEEsLaJxJIiwbDGEOe3UKxr2Mi0oJV08dhhzF49OBHwXm8aSyPXlbx/NYJtOMi2IBW6ypCD29stOwxffPFBxHVEcoBGZaDjE0txt04UlMmGHmMmsOcTmuANr3eI2bFjSRjFnCjAykZCQlwG4XylVURCqlDqhlDoZPP4RgJyI9KZsNyvu+plARLB5TTe2PEtBjBBCCCH1IyI5+GLYvymlvhMsfk5ElgXrlwE4mLbvXPrbacvOozhjSTs6jXsjZH6ztKMJPa15PMIeMUIImXWmLIiJyKtFZA+A5wP4oYj8FACUUo8A+CaARwH8BMC7lVJu0BH2xwB+Cj/D+ZvBtgDwlwDeJyI74HeKfXGq802FqEMse5tqkYk64m4qkYl6329s2Y1b7ttVc/u0WMS2QJA6PlKc9BxZfP2+XfjEz5/E5+94Gq6nYFuC5lzc8WR2ddmWIGdbhkMsWu4qhZLrH8MUxDoNh5jpgKvmEDPPqR1iReN9yAXiVhiVGPxLCIWxMMoxuhGfjEx0Uhxm5r7m/lo8G0pEJva1F3DBqu6K64g6xCLMyMT+ruaKc0wXlkhdvVf6NUtuO/sdYnNTLHnVef342Z+9aM7ONy+Y4+8xIbPIG5ARlygiSyX4RyIiF8P/2+7ILM42Kwys6cHuo6M4MDjW6FEIIYQQMg8I/j76IoDHlFKfMFbdCv8D2MAc+CB2Lcquh98+ewwXsz/slEJEsKm/g4IYIYQ0gCkLYkqp7yqlViilCkqpJUqpa4x1f6uUOl0pdYZS6sfG8h8ppTYE6/7WWP60UupipdQ6pdSNSqnxqc43FfQN97QYQs1IMTuGUAsY0xGZODRexge/87ua26fNqh1aU3GIPX7gBG7+5faK5drxNF524SoFSyoFMVMsEvEFMS30afHEtgSuGzjELIk5vLpa8uFj8/LSrlU7xJpzld1fZr+adnFVdoclO8TMmELDIWb516KFLrPGK97v5T/OO+mRiVn3+cPuJGODnOFIW94dCWLTLUCJZM9lEop2iY1nKzJRUkRDcmpRLRaTkIWCiLQCeAmA7xjL3iki7wyevhbANhF5CMCnANwUuO5PKTav8T88spUuMUIIIYTUx6UA3gjgShF5MPh6OYCPAXiJiGwHcHXwfM7yyL4TGCm62Mz+sFOOs/o7sP3gUOzD24QQQmaeysInEqJv7E+6QywQXabiECulOL6qUS0ycXBk8oLYqz/za4yWXLzzRadj55ERNOUsrOhuCUUpxxJ4gUOsKSGIxQQi0Q4x/3UzY+9cpVD2FBzbikcmmh1iNRxiaZGJubBDzIhM1A6xjMhE/d6b7ivzsZ47H7jdYg6xmKvMP4/uTks6xLKi4CKxKVpmOtRWdJsOselNPp14ZGJ8+WxFJoZiyUwGv5KGknRsErIQUUoNw3fNm8s+Zzy+GcDNsz3XbHPWsg605G1seeYoXnFuf6PHIYQQQsgcRyl1N7I/P3nVbM4yFbYEHap0iJ16bOrvRMlV2H5wCJv6Oxs9DiGELBh4K7kK+mZsFYNYfZGJk3SIlV2v6rnT98l2iA1OwSGmr9NVCld/4g5c9vHb/fMFA9qWBU/5IkVz3g5FOCB+M9u2BHlbIoeYjia0/Q6xsudVOMQ6MzrE0hxiaZGJkSAWba/FLe0Ui5woCaeYofaYIpFenA+6wUyXlC2V+zQZDrG8Y1WsT5IWxZgzlJ/+TkMQs6dXLLCkvs6m5Gumma3IxLneIUamTvjvgBYxQhY8jm3hglVd2LLzWKNHIYQQQgiZNe595ihWL2rBko6mRo9CpplN/R0AwNhEQgiZZSiIVUHfg62WPDRa9IUd8578SLGMz/7qqVCo0H1ZE6U4QXcYAJS9yn1a87pDbPKCmCYpQrnB+Rzbd3hZQYeY2fslxk+ZiB/9px1iYTSh+IKY6yo4Vtwh1m1EJrq1BLEgwrI5bwpi/knM11O/N3bSGZaISjRdYXaKOKYjE01Nyrx5nw9WRA6xMtoNsTDrPn8o8mQct2CIag3rEMtyiLFDjEwTdtDTl5tm0ZcQMj8ZWN2Dxw+cwImxqf89QwghhBAy1/E8ha07jzIu8RRl7aJWtORtPEpBjBBCZhUKYlXQN/yrdYhp51Te6Je6a/thfPwnj2PHwZMA/H6tLD7248dxzod/mrquVK48r5eY5dF9J/DfvrctFO3SYgS1XnB8tJg5R70kX4vIIRZEJopgUVseSzoK4TZJh5jZIWZGFXpKoeR5cGxBayEStDozIxMrxb9RHZmY4hAzc5lDh5gV78GKniP23J8VxuO4IGa6lEyBqjMQ8/R2J8fLaGuKBLHMDrEM91W0PlreYbw+04HfIVZ/ZGJy29mLTEwX5MipQ8Gx8YU3DuD3LlzR6FEIIXOAzWt64CnggV3HGz0KIYQQQsiMMTxexu2PH8SHb30Ex0ZKjEs8RbEswZnLOvDIvsFGj0IIIQsKdohVoZ7IRO10MmPwdGyhNiRVc4h97o6nMteNu5VC2kjJjcURvuaz92Cs5OEDLz0DnS251MhELVpNpUNMU+EQc6MOMTfoEPv73zsXYyUPL/wHP1Yx6azK2VYYI2kZ4cIAxwAAIABJREFUwlTZVeExmnPRNXYZkYlHhou448lDeNGGPqToYRkOsZQOsWCZni3sEks8j80e6xDzv+dTBDFzn6Zc0CFm/HyY71+W8BSKTalr4yKQ+fpMB5YldYlMoYktse1sdXqlmOjIKchLzlrS6BEIIXOE81d1wbYEW3cexYs29DV6HEIIIYSQaaHsenh47yDu2X4Yd+04jAd2HUPJVcg7Fq4+czGuPXtpo0ckM8Sm/g58+7d74HmKVQGEEDJLUBCrQn2Rib6wY4og2rmkBZhqDrFqlFLEreHxckxQ0WKbghbhsl1lx6fQIaZJdqZpsc0JHF6WCBZ3NMWcXPHuLb9D7MRYPDLRCiITS65CzoocYrYlYeQj4Lvv7tlxGI/9zbWpDrHhcf+4aZGJMUEsjEjUQpi/PBTGdLdZZodY3CFmikL6Z6HZcKkVnOhxaywysf4OMQC4ZtMSXLauN7bcPPZ0YInU1yGWeA01sxeZyA4xQghZSLQVHJy1rCMslyeEEEIIma88fegk7tlxGHdtP4zfPH0EQ2NliPgCydsuOw2XrevFwJruWD86OfXY1N+Bf/2Ni2ePjmBtb2ujxyGEkAUBBbEq6Bv+bjVBLBCITCFKP9YRfZPuECunCT7l1G21MFVKEYlCh1hCEHts/wm87J/vwvfefSnOX9mVetzxsotvbt0TPj8xGj+/FqVs2wrdXUDcTZWMHTQdYmFXly2hmGVbFloCEaw1b4d9XxpP+a9Nmvg3NObPZ4qGThiZqIxlEvuejN+LnGuR3cmW+HUAkRiV5hBra3LCGQu56DgT6RBLaj2ff+MAAOCXjz+XvuM0YEl9rqu+tgKu3Li44mdntgSqWrGShBBCTj0G1nTj6/ftQrHsxdz5hBBCCCHzifd8/QE8su8EVnQ34xXnLsOl63rxgtN70dOar70zOWU4a1knAOCRfYMUxAghZJagIFaFeiITtSAW77YKxClXC2KTc4hpQexPrlyHg0PjuGXL7lA0SqLPn+oQCwS94yPxDrHbnzgIAPjxtv2ZgtjNv9yBT/9yR/g8Karp89ki8FRc4PmjF5+OF23oiy3THWJjwbWJ4fLR1+vYgpbA4dXelAsjD03KrkrtSzs5XoIIYp+i0v1uxZhDzArn1ucHKiMTTYeYqbvo7cPIRKtyXXvBCV1+ZmRia6H+DrHs9TMnAolIXcfPOxa+9JbNFctn2yFGPYwQQhYOm9f04Mv37MQj+wZxwaruRo9DCCGEEDIp/uaGs7GoNY9VPS0z+v/3ZG6zYWkbHEvwyL4TeMW5/Y0ehxBCFgT8aG0V9H19r4pDbCyITDS1GS0SacFmPMXpVQ9aUDt7eSdedb7/i1F3ZAHpIlxqh1iw7FiiQywU/DyFLTuP4hM/f7Ji32cOD8een8gQxDyl/MhEQwz5y2s34pLTFkEk6qSyRJBzDIeYITzpaEnHkjBusLVgpwosJdeLXb/m5HgZzTkbpqksjEwsV0Ymho62YHs7wylmbgtEgtT+wVEAwKqe6JM8juEQKwfvoRlr2NY0kQ6x6utb8tMfn2BJtnOtHuzZcojp7/x/B0IIWTAMrPFFsK07jzV4EkIIIYSQyXPhqm6sXtRKMWyBU3BsrFvchkf2nWj0KIQQsmCgIFYFLTpU6xAbCQQxM1ax7MYFsMk6xLSQlnessEfLjEw8fHI8fByJcNG5PUOsAoBjI8WYg0wLF54C/vArW/Cp27bj2HDcRZZ0hCWfa7HNU8qPTMz4Y86MUsxZEjrEQiHKkvB6bUtgBaJYa8EJBS2TkpfuEBsaCwQxQ9HRkYmxDjE7LohFwljcKeZkCGL6oXav/enV66N1WhArOOGMpkOsvY4OsUhATF0dLu9szqVvMAXq7RDL3J8dYoQQQmaIxe1NWLOohT1ihBBCCCHklGBTfyce3TdY9d4jIYSQ6YOCWBX0jXato4yX3YpfUIcCUSrNraXRQs9bvnwfvrllNwBg3/FR/OW3Hg63SfvFpwWcvGOFMXvDxUhc23t8tOKc5rl1RKBephRw1BC8tHDhKYXlXc0AgIf2HI/NkBTATowlBDEjqtH1VKYYoj/1ZIsvLGlhzjKEKP06aZGptWCjreCE8YYmpSodYk05OzZHLiUyUS+LYvfiQpheniaCmev/15sG8IP3XIYlHU3hOi0KthWc8D00O8Ra6+gQ0/6nrE+LaefYTAli80FjYocYIYQsTAbW9GDrs8d404AQQgghhMx7NvV34PDJIg4NjdfemBBCyJShIFYFrcN4SmF4vIwzPvQTfPIX22PbHBgcAxB3iCWFGu0Q+81TR/C7vYMAgA99bxu+sXV35j5A1CGWty20FvxovG9u2Y3tzw3Fzu3v72/rGpGJWmAyj31kOPoFq8UYpYCz+jsAAA/tHozNUMsh5hqCmKeqOMQMN49jmyJT4MSyJYpRtHQcoIPWvBPbXlP24oKYdl0dHymiKWfF5sgFxysakYn6HKFTLBTAkPheOav/2P++sqcFZy/vjM2mfxb8yET/cZMRmdics0PnWXYkYvx7EgX/uF0t0y+IicwPkUkC4W4ejEoIIWQa2bymG0eHi3g6EetMCCGEEELIfGNTcD+OsYmEEDI7UBCrghmZqIUg7fACfFfYcyfGgm0il1fSITZW9vuuxste2JOVFDpS9LBIEDMcYnfvOIwbPnMPAGDUiGIsp0Qm6nPFBLGThkMsjExUYWfXwzUcYhWRiV4kurmeSu37AuKRiabYooUnSyR0cOmIxPe/dAPeeumaWNygplhWcUEs6OXyFNCcTzjEnJTIxEDt1FGUWvy0EzF8sehFw6lWLedbx1q2F5zw9TEdYoWcFQpx2ZGI2iGWvn5ozD/HQnaIAVOPdySEEDL/GFjTAwDY8gxjEwkhhBBCyPzmrFAQG6yxJSGEkOmAglgVIsEo6uEyBYwjw0WUPYW+9gKAuFvKZLzkhm6totGTZeLViExsyUUOIx2baJ5HO5FMMW7n4RHc+Llf4+hwEb1teQDx3jE9gqdUeP5nEp+2Pj6SiEwcLceeh9esFDyVLeCYjiezl0sLS06sQ8z/sbz+/OV43mmLcHpfG/76lWfhrGUd0fV6XuxaOwxhqDlnx0SStMhEPcNpfa2xOSQhiJmz5g1hrpoIo8WqtiYHJVd3iEXvX962kAuuMUtY09pb1notTM6MIFZd8JtLCOgQI4SQhcZpva3oac1jy85jjR6FEEIIIYSQKdHelMPqRS10iBFCyCxBQawKWgtxPQVtvDKdRzqysD/o39JReWU3IYiVvTA2cbzs4fbHD8LQZsJzJIkcUxYcO3qrelrzFfvox+a5/+kXT2LLzmN4/MAQFrf7HVeHDYeYFj1cD+H1lQyHWVo3hxZitDikRSlPRybWcIjZloSCF2A4siyBPp2TOIaI4C2Xrg1dYIAvFrrGrOa6ppwN4+UKHWelcnQ92qG1bnEbAOBY0K0WOtlS+qnigljqZQIATgYOsbZCDmXdIebEHWJ2DYdYZ3M++J4uePW2+SLsuSu6sgeZJG9+wRrccH7/tB93JqBDjBBCFh4igoHV3dj6LB1ihBBCCCFk/rOpv4OCGCGEzBIUxKqgxS9PqVAoKpY9/M+fPoGxkosDQVzi8i5fbNKCjinUAL5DTMcb/ubpI3jrV7bgF489F9smzSE2bnSImXQHvVGmQyqKTIyWmZGKPa15OJbgiOEQ0+KPUioU88wOsqQbzF/mC2JagtACnOv5olxmh5gVObDMywmjCY390jrDzG0BoOTGIxObcnYoWDVlOMRKKQ6x0/t8QUw740zhLjlLTBCrooitD0S2c5Z3ouRph1i0b962w/jFrONcuKoLv3z/i8L5klx95mJ8653Px+8/b1XmHJPlrZeuxVVnLpn2484Eft9Zo6cghBAy22xe04Nnj4zg4Imx2hsTQgghhBAyh9nU34ldR0dwYqxUe2NCCCFTgoJYFaIOsUhMOTg0jptv34EHdh3HgcFRAEB/Z+AQSxGlAN85ph1iyQhCTUJDAwAMBts25+3Y8pEgMtEU0aK4xuhAo8VIEHNsQU9rPhaZKMa+Xsrsh05W3mTSv5z1dtrF5noeXE9lCjym8GU6xPRDU3hKOsQ0pvus5MYjEy0RtAavU3POTnR/+Y91XKV/Pv/E2iG2P3D7WYnoxFhkom12iKWOCAB47UUr8PM/eyEuW98bvi8FI/Ky4Fihay3rMCKC0zLEML1+YE3PvIk2nCn8vrOF/RoQQshCZGBNNwAwNpEQQgghhMx7dI/Yo3SJEULIjENBrApmZKIZtwf4gsz+wTE4lmBxR9Ahpl1WSUHMUzG3VhquIW4dHynC8xRuf+Ig1i1uC+PxNi5tB+CLN+f995/hPqNMvhwIYSXD4TVmnNMWwaK2Ao4YkYl6TE+lzz6Y4hDTkYmup6CUCkUmN+ghy3KIhYKYle4QMx1djpX+Y2keupxwiNmWoLXgxyY25azYHNrZZXaIaUFqWWdTYs7oeP53q2Kf5LyVcwrWL/HfKzfNIeZYoQBIMWdqiGSLioQQQk5dNvV3oqPJwc8ePdDoUQghhBBCCJkSm5b5ghhjEwkhZOahIFYFLXp4SqHoxgWtkuvhxFgJHc25UMBJc1np52OlFAuYgXZ7HRwaw/kf+Tk++sPHcO8zR3HNpii67id/+kL8+TVnAPCFqR88vD9cFznE0iMTbUvQ25bHIcMhpt1kSqkKd9vv9gxi7/HRijm1IKa31bGOYWRiDXeXSFzwslKcWHZGZKJ57GKKQ6wtEMSac3bMqZYWmWhGOP7T68/H9999aWx5KIwZgpUpXk00pi/WIeZYUWQi1ZwpwQ4xQghZmOQdCzdcsBw/3nYAx0eKtXcghBBCCCFkjrK4owm9bQU8sm+w0aMQQsgpDwWxKlhhxxZQrHCI+e6ovG2FIkqaKKWfj9VwiGkxbe8xX4T60j3PwPUUXri+L7Zdd0s+ms90TKV1iBXjgtiyzqYwGtDc1gvcXebsr7z5bvzJ1x+omHPEOGbZVSiWo/hGpbKjBLUGZicEDO0WiwlYGQ4xU5wqu1HMoz5OSxCZ2JS3451kYRccjGXROW64YDnOW9nlz5FwrCXFOX3YiYowBSeKTMw7VjgTxZypIRL9bBFCCFlYvH7zShTLHr73wN5Gj0IIIYQQQsiU2NTfwchEQgiZBXgruQpao/GUirmLAN9tVHIV8o4Vijk6drCcKASrRxDT+yadZO1Nudjzrpbo+aIgShEA3CAqsWzMaR7LF8SacWhoHOOBiBUKeCrqMCsHXWD1UPK8MIaw7Cq4qopDTAtNlsT6wrTryo6JZOnHMB1ayQ4xMzIx2SGWcyp/zLN6ysxox7TttFg30ajDQs50iNkxxxyZPOwQI4SQhcum/k6cs7wTt2zZDaXq+9uFEEIIIYSQucim/g5sP3iy5v1DQgghU4OCWBW0OOIaXVmakuuhWPaQsyUUzvS9mLJbGZlYq0NMaztj5fh2TsKhZApi5s2fNIdYMRERuLyrGQDw3OB4bFtPqViHWPKXb95O/zEpuwrjgejmBbGLmR1ihiMq5hBLcWIlrzm6huhxyY0Ld2ZkYlMyMjHFQuRkXFPoWEvpNjNnm0pkYt6xwhhH3r+bGpbQZUcIIQuZmy5eiccPDOHhPYyXIYQQQggh85fNa3rgegpbdh5t9CiEEHJKQ0GsClGHGFIdYkXXQ96J4vmSPVwat54OsWCf8YQYlXRLmZGJ44ZIlxXXaB5nWVcTAGDf4GhsW6VUrP8sKYh1t8ZdapqyGznEXM8/hlXLISZx15WV4hCr5d4C/MhKV8UdYi15wyEm1QW2XIboFgp3GQ6xyUYdmpGJBccKZ0r+rJwq/P1rz8X/edvFM34eEQHlMEIIWbi86rx+NOds3LJlV6NHIYQQQgghZNI877Qe5GzB3dsPN3oUQgg5pZmSICYiN4rIIyLiiciAsfwlIvJbEfld8P1KY92vROQJEXkw+FocLC+IyDdEZIeI3Csia6Yy23QQOb9UzG0F+IJMyfWQtyWKTKzSIVbLIab3SQpnSXeT6RAzBTEd01h204U3WwT9gUNs3/HRYNvAIeZFkY1KxXvCCo4VCk1JSl7knCt7QWRihlCkhT3bkpjIpy/PFJ6cjFIoU2xLRjvaImgr+KJTc86O9UrlUtxgNaMdg9XJDjF9rIk6xJpikYlRh1jW+zXfed3ASlye6L+bCXyH2IyfhhBCyBylvSmH685dhlsf3Ifh8XKjxyGEEEIIIWRStOQdXLiqG3dRECOEkBllqg6xbQBeA+DOxPLDAF6plDoHwJsB/J/E+t9XSp0ffB0Mlr0NwDGl1DoAnwTw8SnONmVCh5iXHZmYd6xQRPFUukMMAEZq3KTxwg4xX4ySDEHGdIgVUxxiWY4jxxb0d/qC2P7BsWAfQ8wy9hsuRrO2NzmZbqqy64WinOcpeAqZDjEzgtBOcYiZ+2VGJhpiW7HsxaIpLaNDrJCzYtumzZ8mkpnz6P0rHGK27v6amAqTd+IdYlr0q7evjaQjiQhOQgg51RCRncEHjB4Uka0p60VEPhV8oOhhEbmwEXM2kps2r8Rw0cUPH97f6FEIIYQQQgiZNC/c0IdH95/AoaHxRo9CCCGnLFMSxJRSjymlnkhZ/oBSal/w9BEAzSJSqHG46wF8NXj8LQBXyURVh2km6hDzHWEmJddDyfWQs61Q4IkcYpWun5MJQSx5ZVoQ09s5GZF9TTkbW/7fqyuOb3aIpQlAlgia8za6W3LYqx1iwT4l1wvPDyD2Ceu2ghMTc0zGy5FLyw1iF7PcOpbRzWUKYqFzrK7IxPj1mq+zLZEg1pyzY+eYiENMC3NiCHgmWsiaqAhjXl/eiEwsURCbEpZMXJwkhJB5yBXBh4gGUta9DMD64OsdAD47q5PNAS5a3Y3T+1oZm0gIIYQQQuY1l63rBQD8+im6xAghZKaYjQ6x3wNwv1LK/HjDl4NPOv83Q/RaDmA3ACilygAGASyahfky0SKOUgrFcjzysOSq0CGmRZTQIeZWihxJQUwlNtHJeTquUAsvacJNb1u+YlnoEHMVCo5dIWJpkWlpZzOe0w6xYIhi2YOp4Z0cj661teAgnxCU9HMzWtHTkYk1oghtCwmHWLDerhTJkpguslLZi3WIWZagNR9EJubt2LZpAmGW6KY3tTMESX2sicb0SUIQ0yLdqRqZOFsIpEJcJoSQBcb1AP5V+fwHgC4RWdbooWYTEcFNm1fh/l3H8eRzQ40ehxBCCCGEkElx9vJOdDbnGJtICCEzSE1BTER+ISLbUr6ur2PfTfCjD/+Lsfj3gyjFy4OvN050aBF5h4hsFZGthw4dmujudWMZUYhpDrGiq3yHWLidvy4tBq9Wr4UW0/R2+hhpwo0kXFZA5PZyPQ+OLWgJxKHwWoLtu1tyOD5a8rd1I4eYOwGHmO7DMmMgdexilnPKdF45MUGs0iFWK84Q8J1VsQ4xC3GHWI3jZbrQrESHWEVk4uQcYuZhbEvw9svWAgDOXdE1oeOQOK/bvBJXn7mk0WMQQshMogD8LOhkfUfK+vADRQF7gmULildfuBw5W/CNLbtrb0wIIYQQQsgcxLYEl65bhLu3H4ZKfpKeEELItFBTEFNKXa2UOjvl6/vV9hORFQC+C+BNSqmnjOPtDb4PAfgagIuDVXsBrAz2dQB0AjiSMdMXlFIDSqmBvr6+2lc5ScLIRA8oumkdYq7vEAvEjrQeLy0mDY/HHWZJ9L7aSabPl+m4Sgg3brB9yVNwLEFLLi6IaQGoqyWH4yPF2Jwl14NnzHyyQhCLH6s5ENuGDYeYjkys7RCLdz5ZxvLktWUdQ89cdlV4XbZI2K/W3pSLHaOQmB+IhK0kyU6zZByfFtcm6kpKHucF63qx82PXoa+9VpIoqcb7XrIB1569tNFjEELITHKZUupC+NGI7xaRF07mILP1YaJG0dtWwEvOWoLv3L8H4+Xqf3MRQgghhBAyV7l8fR8OnBjDjoMnGz0KIYScksxIZKKIdAH4IYAPKqXuMZY7ItIbPM4BeAWAbcHqWwG8OXj8WgC/VA3+OISOTPSUH49oUnJ911jejiITow4xQxALBJRkZGKSpENMo6MTk2ghSAtu2sDmugqOZaElcEtF1+Jv39mcx6B2iAVzFl2V7RBrcpBPRA42B2LbkZNRCmatyETTeeWkxCOa+zkpEYfmMQA/atBVCoXg+i1L8OIz+vCltwxgw5K2mOiW1oGWFqNozpHlAIsiE+tTxL737kvxidedV9e2hBBCSBLjg0QH4X/Q6OLEJuEHigJWBMuSx5mVDxM1ktdvXoVjIyX8/NHnGj0KIYQQQgghk0L3iDE2kRBCZoYpCWIi8moR2QPg+QB+KCI/DVb9MYB1AP4q6Ap7UEQWAygA+KmIPAzgQfg3bP5XsM8XASwSkR0A3gfgg1OZbTrQoodSCqWEQ6xY9lAse8jZYkQmaodYtG3kEKsliPnfTyacZLUcYtr95AbnLAcurWRkohbQultyOD5SglIq0yFWKzKxOe+LbY/tPxEucz0FT2U7p/RrZEncIaYfxgSxDBHQfClKrh+ZWAjEOccSOLaFKzcugYjAPIRtSUVEop1xDjslwtFEHydj9wrOX9mF11y4or6NCSGEEAMRaRWRdv0YwEsRfZBIcyuAN4nPJQAGlVL7Z3nUOcFl63qxvKsZt9zH2ERCCCGEEDI/WdnTgjWLWnD3DgpihBAyEzi1N8lGKfVd+J9WTi7/KICPZux2UcaxxgDcOJV5phvL6AardIh5KLke8o4VijlTcYjpfSodYtWFGS1Wlb1IjHNsCV1cGi3wdLXkUPYUhotuKKKVXA+eirY3Rbm2glMxU3PQIbZt3wmIAKf3tfmCmKcyhSTTeeWkxCOaglhnc67qMQDgK7/eCQBY1tnkHzcpeMViGf2ow7IXXVeWQ0zvlvGyT7pDjBBCCJkESwB8N4jddQB8TSn1ExF5JwAopT4H4EcAXg5gB4ARAG9t0KwNx7YErxtYiU/+4knsPjqClT0tjR6JEEIIIYSQCXPZ+l585/69KJa91NQjQgghk4f/Va2C2Q2WdIiVXRU4xKLIxMghFgliOcdfV3dkYjHaTqRS6NFoh5OODHTd6NyOJWhNRCbq7bua/Z6t4yPFcM5i2YuJeLUcYk2B2PbIvkGsWdSK1rwNV9UXmWhbEtvGSjiyCobAWHGMFBFKX39SiLMS50gKYDW72TLW6+MkO8EIIYSQ6UYp9bRS6rzga5NS6m+D5Z8LxDAon3crpU5XSp2jlNra2Kkby40DKyACfHMrXWKEEEIIIWR+cvn6PowUXdy/61ijRyGEkFMOCmJVEBGI+JGJRTdeZ1ZyPRS1Q0y0Q8xfVza2zdl1RiYGgpQpnGW5w8x1SYeY7hBrTkQmBmOgs8V3Xx0fKYUimO8QSxfEetsLlZGJgSA2VvL8vi5L4HoKSmU7p/SlWAlBLBmZuLy7OfOa09COraTAFXeIScU1ZMUypjnW0var8tYQQgghpEH0dzXjRRv68O9b96Cc+DATIYQQQggh84Hnn74ItiW4mz1ihBAy7VAQq4ElkhqZOK4FMdsKxZE0h1g+FMRctBWyEypdpfDY/hN49shIuCxLlDHXOYHA5BqRibYlaElGJoYOsUgQSzrEtIZ0crwMEeAH77kMr75geSjqaZoMsW394nbYIuHrk+m8CjvE4tuEnV1aEOvKFsRMF5tmaKyEC1d1YePSjsT1xkW35DVkRyZGc6ah92NkIiGEEDI3uWnzShw4MYY7tx9q9CiEEEIIIYRMmI6mHM5b0Ym72CNGCCHTDgWxGljii1XJyMTxkgulfMErjEwMO8SibXWkX9H10NGULYh5HvCyf74rJvpkuZgAwLG1kORHDEYdYgo5Oy0y0f/e1RJEJo4Ww3lLrh93aPadFRwLZy/vRFPOrnBXmWJbb1setiXh61MzMlHSIxOHi36/VzVBzHSxaY6cLOI777oU1527LPV8+hxJQay2cFfdIZYyCiGEEELmAFduXILetjxuuY+xiYQQQgghZH5y2fo+/G7PcQyOlBo9CiGEnFJQEKuBiMBTqsIhNjzuCzg5o/PKTesQM4SYlioOsTSxp16HmGNJKMKVXb/HqzIy0Z+ju6XSIVZyPXieCoWv4fFy2BMGAIWEmGQeu7MlFwhi/rGyjFOm0GRGQWrhat/xUQC1BLHKZeW0hUhGJlY6wpICWbifpffJEMSC45Q9xjARQgghc5G8Y+H3LlyB2x4/iINDY40ehxBCCCGEkAnzwvW98BTw66foEiOEkOmEglgNbBEohQqH2EjR79nyIxN1h5iKfQcQc1clXVsmrlLoac3j5ecsxcal7QDq6xDTnVxlIzLRsazKyMTgUB1BZOLgaMmIWVQoeyp0s50cL6PJifbP6hADfBt3zCGWISTZxrxWQqwCgLWLWgEAzzttUeY1exniVxqmuW4iDrFCcG1NiddPo49TcmkRI4QQQuYqr9u8Eq6n8O3f7m30KIQQQgghhEyY81Z2oa3g4E72iBFCyLRCQawGlvhCTDEhiJ0c9wUx0yE2NFbGhg/9ONYDZopJbYV0kQXwz1F2PSxubwpFmeoOMf+4kUMsEuMcWypELDsQcppyNppzNo4NF2PuqvGyF4o9w+MumnLR/sljmWJRZ3MOlkj4+tSKTLQkclmZ2984sAK3f+DFuHhtT+Y1p7nosjCFOZHKa8jqELt8XS8+9wcXYcOSttT1er+yS4cYIYQQMlc5va8NF6/pwTe27IJizjEhhBBCCJln5GwLl5y2CHfvYC8uIYRMJxTEamCJwE2JTBwJOq8KthWKL88cHq7YLhaZmK8WmRiIWVYUKViPQ8y2BLZlGfGHKlgW39cUiJZ2NmH/4Fis62ys6GZGJibdVS1GZGJHcw6O4RDLihrU+pOeV6O3FxGs7W3NvF4giqSsB/P6JcUhltXP5tgWrj17KcS4jtUt9j/9AAAgAElEQVSLWvCys5eG6wGgNAG3GiGEEEJmn9dvXomdR0bwH08fbfQohBBCCCGETJjL1/di99FRPHtkuNGjEELIKQMFsRpYVnpk4nDoEJOwNyvNHZW3TYdYlcjEILbQtiMxy85wMZnnsoNOLteNHGI526qYxRTX1va24qlDJ1E2Yv/Gym4463CxHLrUgDocYpagVFaxuZJEDjFJ9HtlX2OSiXzA20rMkXSEVXPfJbnjz6/AZ//gIv84Fh1ihBBCyHzg5ecsQ3uTg29s2dXoUQghhBBCCJkwl6/vBQDcxdhEQgiZNiiI1cASP6ov2RmlHWJ52w7FlbSOq3iHWJXIRKVSHGLZb0+4jZ3sEPMdYkl3mSkQndbbip1HhmMiX8lV4ayeApqMua/auAR/fMU69LblAaR0iInhEMsSxMQQxCxTEMu8xAqSkYn/eON5+PUHr0zdNtlllnfiMZRJx1i9aIdYeZIdYjec3z+p/QghhBAyMZrzNm44fzl+tO0ABkdKjR6HEEIIIYSQCbG2txXLu5px13bGJhJCyHRBQawGlgi8lMhELUDlDEdXsmcMiDvEulvy+INLVqWeJ3SIWZG7q3qHWLSNY0sYf1h2PTiJWEIg4RDra8VYycOeY6PxWQ0RzHSBLe1swgeuOSMUkZqMyMSmnD9vMYxMzJhX9Lzx65qIU8tNCI5n9Xegv6s5/XyJ4+ZtLYTVfm2rofvPSt7EHWI7P3Yd/ummCyZ1XkIIIYRMnNdvXoli2cN3H9jT6FEIIYQQQgiZECKCy9b14tdPHWFSESGETBMUxGogInC9yshETc6xQvfTWMmtWG+KTHnbwkdvOAfrFrdVbKePn6u3Q0wLOxJ3iLmegmNbNRxi/vkPDo3HZ7VNQazyR0Nfp+kQk+D8ev6kMyt5fkk4xGQKkYkdzbnMbZNRjFrMW7OoFS15O3S7TZScNTWHGCGEEEJmj7OXd+Ls5R24ZctuqIlkLxNCCCGEEDIHuGx9L4bGynh472CjRyGEkFMCCmI1sC1AKYXxcrogVjD6utK2MaP5dNxems6lHWh+h5gVnLuaQyzaxrEkdE+Vg9jFF5/Rh7aCg772gn9uUxDra009ZpZDLJpfKrbTM+hIyazIRP0y2IYgNlGXVjIysb0pu5MteWz9Plxy2iI8+pFr0dUyOUHsyjMXA/D/ICGEEELI3Oemzavw+IEhPLSHNxEIIYQQQsj84tJ1vRAB7maPGCGETAsUxGqgIxOrOcTsOh1iOq4v6V4CIoeYU69DLNYhZoUOsVIQmbi4ownb/vs1OG9FV8U5+9oK4WNTOIo5xJxKQSzs30q6zyQS5LIcYnq5ZUWzTzS1MCmIteWzBbHksXOhGDm5qETNhau6sfNj1+HCVd1TOg4hhBBCZofrz+9Hc87GLfftavQohBBCCCGETIie1jzO7u9kjxghhEwTFMRqYNWITMzbFnRdV5pDTHdXAZEok+aM0vvalgW7jp4r24rENdMhVix7qSKcKa5ZloSRiE1mpKNTPTJRi1qOnXSIVc6VxDLm1aLURMWpRIVYphsNqIxizDtRhxkhhBBCFg7tTTm84txluPWhfTg5Xm70OIQQQgghhEyIy9b34oFdx/m3LCGETAOUB2og4kcmljI6o3J21CE2XqoemZgUxAZWd+P2D7wYAFBMdYhlvz2mi8zsECu6cUHMyRDhWgJ3lRmNWCsyMXSI2ZJYHu2XGZloiGBOFadcNbzgGj903Zn48ls3T2jf0CE2UVsaIYQQQuY9N128EiNFFz94aF+jRyGEEEIIIWRCXL6uF2VP4T+eOtLoUQghZN5DQawGtuVHJpY9r0IIAnwRKeoQqx6ZmBSCbEvQkveFJ90h5kcg1u8Qsy3//K7nhccxow+djGM1B4JXTBAz9itU6RDT4tKLNvQFx462yRrZvKbI3ZZ5eanoyMTT+lpxxRmLJ7RvKEZOMTKREEIIIfOPC1d1Y/3iNnx9y+5Gj0IIIYQQQsiEuGhNN5pyFu7eUV+P2F3bD+Gvb30k9T4lIYQsdLJLmAgA3SEGuJ5CwbFRcuP25LzhEBtLcYiZglg+4dayRKD1mVAQMx1iKQKcJnKb+ccruwpKqUqHWIYgpoW4Qm4ykYmCJz56behgM0WmLMFJDIdY1Cc2MXFKm/SScYj1MF0dYoQQQgiZf4gIbrp4Ff7mB4/isf0ncOayjkaPRAghhBBCSF0UHBvPW7sId9boESu5Hv7nz57A5+94GgCwelEL3nrp2tkYkRBC5g10iNVABHCVCgSxypdrcg4x/7ltReJQ0ewQs9JjDk1Mh5juEHM9BaXiTq/syMTAIeZkRCY62ZGJjmWh4NiRsJfoJ0ufF+G1m4LgRFCBQ2wyLi/t7mNkIiGEELIwefUFy5G3LXyDLjFCCCHklEdEviQiB0Vkm7GsR0R+LiLbg+/djZyRkIlw+fpePH1oGPuOj6au33VkBK/93G/w+TuexhsuXoXnre3BZ27fgeE51Dt279NHcOPnfo2jw8VGj0IIWcBQEKuBLQLXVfAUUgWxnB2JWuPl+jrELMMhpcWh9A6xbPEmcn75AtO+46N4/MCQfx7HPGdGZKIWxDIdYimRiYFQZwpuyTmzxCrbiImsJxIyDdNlNlHCPjaV3gVHCCGEkFObntY8rjl7Kb5z/x6MlRgfQwghhJzifAXAtYllHwRwm1JqPYDbgueEzAsuW98LALh7e2Vs4v/30D5c96m78PShk/jMf7oQf/eac/CXL9uIwyeL+Mqvd87ypOk8+dwQ3v6vW7Fl5zFs2Xm00eMQQhYwFMRqYImgHPRz5TMcYlprSbu5UqgiTlkSiTyRQ2xiHWJO4BDbNziGV3z6bn+mWIdYukOsNe8E80XCV8GuHpmorzMZ5Wi6rrJm1tuIRILfRM1aH3vNOXjT81fjktN6JrYjIoda2aMgRgghhCxU3rB5JU6MlfGTbQcaPQohhBBCZhCl1J0Aknfdrwfw1eDxVwHcMKtDETIFzljSjr72Au4yesRGimX85bcexnu+/gDWL2nDj/7kclx37jIAfofu1WcuwefveAqDI6VGjQ0AODA4hrd86T405WyIAI/tP9HQeQghCxsKYjUQAUpBeZUWj3KGIFRw7NCxlOYQy6c4xELBSwyHWLBvzjYdYtlvj9kNZie2y6eJcAlX1VQcYklBzDx2ZmSi4RCzQkFsYopYf1czPnL92WEM5ETQ53TpECOEEEIWLJectgirelrw9ft2NXoUQgghhMw+S5RS+4PHBwAsaeQwhEwEEcHl63pxz47D8DyFx/afwCs/fTe++dvdeNeLT8c3/svzsbKnJbbP+1+6AUPjZXzhrqcaNDUwNFbCW758HwZHS/jyWzZj7aJWPL5/qGHzEEIIBbEaWCIoBXGGhUA80sLQ2cs7Eh1i1SMT9X6xyETtEHPNDrF6HGKRuJaMVox3iKUfK+wQM4SvXA2HmD5GLiHAmcfOGtkyXGHOJAWxqaDP6dEhRgghhCxYLEvw+s0rce8zR/H0oZONHocQQgghDUL5JeWZNwhE5B0islVEth46dGgWJyMkm8vW9+LocBF/88NHcf1n7sGJsTL+79ueh7+4dmPsnp7mzGUdeOW5/fjS3TtxaGh81uctlj380f+9HzsOnsRn/+AinL28ExuXtePxA3SIEUIaBwWxGtiWIYgFDqrRIBrxjZesBhAJO+MpkYlmn1feSYtM9Ndph5hjRCZW7RAzhC474dgynV5ZkYktQWSiKYjZloSCVpNT6RALBTEnWxDL7BAzRDCrDsFvutHvESMTCSGEkIXNjRetgG0JvrF1d6NHIYQQQsjs8pyILAOA4PvBrA2VUl9QSg0opQb6+vpmbUBCqnHZOr9H7Mv37MQLTl+EH7/3clwaLMviz16yAUXXw2du3zEbI4YopfDBbz+Mu3ccxt+95hy8cIP/72jj0g48e3QEw+PlWZ2HEEI0UxLERORGEXlERDwRGTCWrxGRURF5MPj6nLHuIhH5nYjsEJFPSVCiJSI9IvJzEdkefO+eymzThSVAMRGZ+JYXrME/vPZc3HjRSgCRsDNWIzIxcogh3C+MTHSjDjGnDsHIFM3GS/HzxgWxdHEtLTLRP7f/vJASmZgl1E00MlHvP4sGsXB2OsQIIYTMF0RkpYjcLiKPBn9vvTdlmxeLyKDxN9dfNWLW+cTijiZcuXExvv3bPeEHkgghhBCyILgVwJuDx28G8P0GzkLIhFnc0YR3X3E6PvzKs/ClN29Gb1uh5j5re1vxuoEV+Nq9u7Dn2MgsTOnzjz97Et95YC/e95INuHFgZbj8zGUdUAp44jnGJhJCGsNUHWLbALwGwJ0p655SSp0ffL3TWP5ZAP8ZwPrg69pg+QcB3KaUWg/gtuB5wxERlMpxh1h3Sx43DqyMxQACSL2pEu/zSkQmihGZqB1idtQJluzqMjFjB4+PFGPrYjGN+pwJoUo7wMzYQlOgS4tM1OdM2rDNY2eJePo0ltGbNpsOMT07O8QIIYTMI8oA3q+UOgvAJQDeLSJnpWx3l/E310dmd8T5yRsuXonDJ4u47bHnGj0KIYQQQmYAEfk6gN8AOENE9ojI2wB8DMBLRGQ7gKuD54TMK/78mo1466VrMz+QnsZ7rlwPCPCp27bP4GQRX7t3F26+fQdu2rwS77lyXWzdxqXtAMAeMUJIw5iSIKaUekwp9US92weW9A6l1H8Eec3/CuCGYPX1AL4aPP6qsbyhWILKDrGEUCUimd1ZOWPbXKLPyxJJiUy0Mnu/TEy31tGEIBYX4dJdXXobUx6yJHJvNaU4xCzLnzc5l3nsrF6wSASL3GKz2SGm/1Bw6RAjhBAyT1BK7VdK3R88HgLwGIDljZ3q1OBFGxZjaUcTbtnC2ERCCCHkVEQp9Qal1DKlVE4ptUIp9UWl1BGl1FVKqfVKqauVUkcbPSchs0F/VzPeeMlqfOu3e/DUDPfo3vbYc/jQ936HK87ow0dvOBuSuPe3orsZ7QUHj+1njxghpDHMZIfYWhF5QETuEJHLg2XLAewxttmD6MbOEqXU/uDxAQBLsg48m+WmtiVh75SOP8ylOLeSItGl6xYBiItMuYRby7YkFNPMyMRI7Mp+e8JYRVtwfKQUWxePaUwXn7QgZkYImn1kzSmCmGMJcikz2TFBLH1evY0YDrFZNIiFIhwFMUIIIfMREVkD4AIA96asfr6IPCQiPxaRTbM62DzFtgSvG1iBO7cfmtXoGEIIIYQQQhrBu158OppzNj7x8ydn7BwP7T6OP/7aA9jU34mb/9OFYWqViYhg47J2PH6AghghpDHUFMRE5Bcisi3l6/oqu+0HsEopdQGA9wH4moh01DtU4B7LVC5ms9xUREL3lu4Qs1NEIf2Jh/aCg50fuw7nrugKtjUELu38SjikbEsMh1i9HWJWeKyjw1UcYk66q03HP3pGhKBdwyFmW5IqBiZjF9MIr1UiEXA2HWJ26BCbtVMSQggh04KItAH4NoA/VUol/8/xfgCrlVLnAfg0gO9lHGPWPkw0X3jdZr/L4Jtb99TYkhBCCCGEkPnNorYC/vCytfjhw/uxbe/gtB//mcPD+MOvbEFvex5festmtBaczG03Lu3A4/uHoFhrQghpANn/dQpQSl090YMqpcYBjAePfysiTwHYAGAvgBXGpiuCZQDwnIgsU0rtD6IVD070vDNBWmRiqkMsEHdCAcpwZtlJh1iwu/6ghCm6xR1itTvE0gQo0yF21cYleO6qcSztaIpvE8xpCkRmHGJah5gtkvrpjrhDrHpkol7vWFaDBDEqYoQQQuYPIpKDL4b9m1LqO8n1pkCmlPqRiPyLiPQqpQ4ntvsCgC8AwMDAAP/PE8CK7hZcvr4P/751N9571fpZ7TYlhBBCCCFktnn75afhX3/zLP7xZ0/gy2+9uK59yq6HB3cfx3MnxnFkeByHh8Zx6GQRh0+O48jJcRwOHo8UXXS15PCVt16MvvZC1WNuXNaOof8oY8+xUazsaZmOSyOEkLqpKYhNBhHpA3BUKeWKyGkA1gN4Wil1VEROiMgl8CN/3gT/08wAcCuAN8MvNX0zgO/PxGwTxbYkjDMshGJXtiiUjCi0LVQKYsltRDAeCGI526rTIRad7x9eey7+/FsPh+tMh9jSzia87yUbKvbX11I0FDHbkvDampyUyETbCq8hbZZqM7c3ORABmvP+cS0LEyoAnSqhIMZbgIQQQuYJ4tvPvwjgMaXUJzK2WQrgOaWUEpGL4bv/j8zimPOamzavxLv+7X7c+eQhXLFxcaPHIYQQQgghZMbobM7hnS86HR//yePYuvMoBtb0ZG5bdj1894G9uPn2HXj2SBQxLgIsas1jUWsBve15XLCqK3z80rOW4vS+tppznLnMDxF7/MAQBTFCyKwzJUFMRF4NX9DqA/BDEXlQKXUNgBcC+IiIlAB4AN5plJW+C8BXADQD+HHwBfhC2DdF5G0AngXwuqnMNl3YllURmZjm3NKLtGBkCmP6cUVkoiF8lWIdYvFjpBEeyxLcOLASi9ry+MOvbAUQF8Sy0C6y8ZJrXKvvTsvbVqpY9QeXrMIlp1X+sqxHELtm01J8712Xhp8S8R1iNcecNvRcHjvECCGEzB8uBfBGAL8TkQeDZf8PgFUAoJT6HIDXAvgjESkDGAVwk2L2SN1cfeYSLGrN4+v37aIgRgghhBBCTnne/ILV+NI9z+Dvf/oEvvGOS8IKGE3J9fDd+30hbNfREWzq78Cn33AB1i9pw6LWAnpa81NOVjhjSTsA4PH9J/CSs5ZM6hiDIyV88hdP4n0v3YCOptyU5iGELCymJIgppb4L4Lspy78NP94nbZ+tAM5OWX4EwFVTmWcmyFmCsUA0KmT0cQGmC6xS7NIClxah9LZaGBOJnFrxDrFsYctObFMwHF1pkY5J8ikOMS3eFVLiEgFgU38nNvV3Vs5i/PLMikHM2RbOW9kVm382o4n0jGVGJhJCCJknKKXuBlD1l6VS6mYAN8/ORKceecfCay9agf999zM4ODSGxe1NtXcihBBCCCFkntKSd/CeK9fhr77/CO7afhgv3NAHwBfCvv3bPfjMr3Zg99FRnLO8E//7TQO46szFFaLZVGktOFi9qAWPHUjWI9fPj7ftx1d+vRNnLG3HGy5eNY3TEUJOdWYkMvFUwrEF2lS0uKOAvGNheVdzxXZhhGGKQ0ynDIbLwnXRvqkdYlWErdB1ltL5VY9DbEnQKbZmUSuAQ7FzN+Uq4xKrYbrJ6tW4bEum/RdqNVYt8i3YF6zqnrVzEkIIIWTu87rNK/H5O5/Gy/7pLqxe1ILl3S1Y0d2M5V3NWNHdHDxuCWOfCSGEEEIImc/ctHkVvnDn0/iHnz6B553Wg+/cvxc3/3IH9h4fxbkrOvHXr9yEKzdOvxBmcubSDjy+f2jS+9/3jB9E9qsnDlIQI4RMCApiNTD7wha3N+HhD780VTDSvyRySRdY0MslUukMs4znWhBzbInFIWahnWH6GKZDrGDXvmFz9vJOfO3tz8NFa7rxlV/v9I8lWhCrLaiZmNGO9bq+bEtQh5Ft2tjU34nb3v8irF3UOnsnJYQQQsic5/S+NnzqDRfgricPYe/xUTy0+zh+sm0/Soni0UWteQys6can3nBB7O8uQgghhBBC5hN5x8J7r1qPP//Ww3j+3/0SR4eLOG9FJz56w9l48Rl9s/IB9o3L2vHTRw9gpFhGS37it6fvDQSxu7cfRrHs1WUOIIQQgIJYTUyXVjX3lI5DzCXELO26yllW+AsldIaFkYmCcmBDcywrcohV6xCr4hDLOfX94nrBut7Yc0v8622a4E2euEOsTkFMpO5tp4t6ij0JIYQQsvB41Xn9eNV5/eFz11M4ODSGvcdGsefYKPYeH8WOgyfx3Qf24uv37sJbLl3bwGkJIYQQQgiZGq++YDn+//buOzyu6l77/nftaepdsmzZllxlg8E2lmwDBgwpkEYCSQyhBDCBkM5JOSd5kpM355ycJ+VJIAUSQkJLo4RAAiEQmsGBgC0ZY5q7LVe5yOp9ynr/mBlZtlVG0kgjyffnuuaaPXtm9iwtjaSluff6rfvX7gbgxyvms3z2yARhUXMKM7AWthxsZkG3JVZisa8+PD4/a0Yu/9p+hMqq2hM+4xQR6Y0CsX50nyHW1+yn9KRwV0ZniCVHgjOvKxxwdV/Xq6tkYldo1v31uq8h1tcMsWMf0/1MZa9rcGdFRNc7S/IM7A9g99cbyAwxJ8bHioiIiIwkl2OYmJnMxMxkykrC+6y17K9v47ZV21lRPmVQZ7KKiIiIiIwGbpfDI589O2Gvf8rEDAA2VTcOOBCriMwOu/nds6msWsOqzYcUiIlIzDSftB+xlgPMSPYc8/gPzp/EfSsXk53qDZdN7B4adc0UO7aEIoDLZbrKIcYyQ6wrEIvMEAvP8hrct9WJhHEDLZk4pzC9a3tAgdgw52FP3XwOf/vCsuF9ERERETkpGGP42oWl1DR3cN+/diW6OSIiIiIiY9bk7GRSvS42VjcO+LlrdtaS7nOzqDibJdNzWLX58DC0UE52//bg6/z+Vf3fNx4pEOtH95KJfQVUmZFALFqzNs3n5rzZ+V3P8/Qwiyq6q/uU5GNniPX+7elthphnkGEYhIO5SxYWccnCyQN6XnFuStd2rGUQ3ZFSksNpTmEG84oyh/U1RERE5ORRVpLD8tJ87nhxO43t/kQ3R0RERERkTHIcQ2lhOhsPNA34uWt3HqGsJBuXY1heWsC2Q83sqW0dhlbKyaqupZNH1+/j4XV7E90UGQYKxPrRPWDqq8Rf5nEzxLrrtWSiOTbUCj8/xjXEXD2vITaURSRdjuGqpcVcsWTqgJ7XPdCLNeNynJFfQ0xERERkqL763lIa2vz85p87E90UEREREZExa+7EDDZVN2Ktjfk5Nc0dbD/cwuJpuQCcXxqejPDC5kPD0kY5Oa3bVQfA2/sbaOsMJrg1Em8KxPpxbFgVQyDWwwwt13EzxKKH6TkQi20NsejaZtFwzetyMAZ8QwjEhpJPzSpIO6Zd/XErEBMREZExaF5RJu+bV8hd/9xBbUtnopsjIiIiIjImzZmYQWN7gP0N7TE/J7p+2OJpOQBMy0ulODdFZRMlriqqwu8zf9CyYW99glsj8aZArB/dSyb2FeBEA7GeHhFeQ6zbOmHHBWHRwxoTDri6Zoi5+grEjp0hZozB53aGXDJxsB64cSk//vh8MlM8sb3WCKwhJiIiIjIcvvye2bT5g9zx4vZEN0VEREREZEyaW5gOwKYBrCO2ZmctSR6H0yJLpBhjOL+0gH9tr6Hdr5k8Eh8VVbVdkz+is8Vk/FAg1g9PtxlPfQVU0UCsrYdfvm7H4O2h9GI0EIoGUcfPDOtrhlh+ug9jIC/N17XP53YNuWTiYOWm+fjootjXHrvmrBIuK58y6NcTERERSZRZE9L5yMIi7vtXFQcbYz+jVUREREREwkqjgdgA1hGrqKpl4ZTsYz7/XF6aT7s/xJrI7DGRoWj3B3lzXwPvmjuBWQVpVFbpfTXeKBDrR/eQqK8ZVNFArLWHuqK9zRBzegnAYllDbNaEdCq++W7mTszo2pfkcY4J3gaqrzXS4m1F2RQumjdxxF5PREREJJ5uftdsgiHLbc9vS3RTRERERETGnPQkD1Nyknknxhlije1+3qlu7CqXGLV0ei5JHodVm7SOmAzdhj31+IOW8pJsykqyWberjlAo9nXuZPRTINYPT/cgK4Y1xHoKxLxuFz63q+t2VxBmjpY7hKOz0bJTvMdc96b77DAIzxBLVMlEERERkZPJ1NwULiufwgMVu9lT25ro5oiIiIiIjDlzCzNiLpm4rqoOa2HJcYFYksfFWTPyeGGzAjEZuuj6YYuKsykrzqGxPcDWQ80JbpXEkwKxfri7BUxup/fuyugKxAIn3PfV987m/7x/btdtV1fJxOiMsMj+SPhWkpfKi19bfsIZD/1J8jiDKpkYzcGGUjJRRERE5GTzhQtm4RjDT5/bmuimiIiIiIiMOXMmZrCzpiWm9b/W7KzF7RgWTs0+4b7lpflUHWllZ03LcDRTTiIVVXWUTkgnK8VLWUn4vVa5S2UTxxMFYv3oXrawjzyszxlip0/OYlHx0V/W0UMeP1Os+2sV56Z2zRyL1WDXEDs6U23ATxURERE5aRVmJnH10mIeeW0v23TWoIiIiIjIgMwtTCdkYcvB/tcRW7vzCKdPziTZ6zrhvuWzCwBUNlGGJBiyvLarrisIm5qTQl6aj8qqugS3TOJJgVg/uodUfc8QcwPQ2nHiDLHjdc0MixzamGPXDhus0ydnMm9S5oCf58Tp9UVERERONp9ZPoNkj4tbn92S6KaIiIiIiIwpcydmALCpuu9ArK0zyBt7G1g8LbfH+6fmpjAjP5VVKpsoQ7DpQCNNHQHKS8JV24wxlJdka4bYOKNArB/dSybGMkMslhlaXSUTnWODqL4Ct1j87yWn8e0PnTLg53WVTNQUMREREZEByU3zsXLZNJ54o5q39zckujkiIiIiImPG1JwUkj0uNh7oex2x9bvrCITsCeuHdXd+aQFrdtT2uJyNSCyiM8HKu73PFhVns6e2jYON7YlqlsSZArF+xDpDzOd28e0PnsJDnz6z32OesIZYtGSiKzGBlDmuhKOIiIiIxO5T50wnI8nNLU9rlpiIiIiISKwcx1BamM7G6r4DsbVVtRgDZxSfuH5Y1PlzCugMhnhl+5F4N1NOEhVVtUzKTKIoK7lrX1lktpjKJo4fCsT60X2GWH8lBVcum8asCen9HvP4EoVdM7QSFEgdH8yJiIiISOwykz18+rwZPLfpEK/t1j9KIiIiIiKxmjsxg00HmrDW9vqYtTtrmVuY0VWhqydlJdmkel0qmyiDYq2loqq2KwCLOnVSBkkeR2UTxxEFYv3wdJu1Fa/A6ugMsWNvuxMdiGmGmIiIiGZc/M4AACAASURBVMigXHd2CXlpXn70j82JboqIiIiIyJgxd2I69a1+DvRSkq4zEOK13XUs7qNcIoSrd509M49Vmw73Ga6J9GRvXRsHGzuOKZcI4HE5LJiSpRli44gCsX64jimZGJ/AKHqY44Mo1xDXEBtqezRBTERERGRwUrxuPrt8Jv/afoSXt9UkujkyAg41tnPzA+t5dYfK8oiIiIgM1pzCDAA2VTf1eP+b+xpo94f6XD8s6vw5Beyrb2Pboea4tlHGv4qq8Ayw8pITy3KWFefwTnUjLR1an248UCDWj+7rhjlxSoxOLJkYvvYkaA0xx9EMMREREZGhumLJVIqykvnWX97SP0vj3KHGdi6/81X+8vp+rr5rDY+u35voJon06fU99WzYU5/oZoiIiJxgzsTw8jMbD/S8jtjanZGgIoZAbHlpPoDKJsqAVVTVkpHkZnbBicshlZVkEwxZjaXGCQVi/egeUsVrhpjruADKpTXERERERMa8JI+LH6+YT9WRFv7nb+8kujkyTA41tXP5r1/lQGM7d11TRllxDv/24AZ+9txWleeRUcVayz+3HuayX73CR25/mUt+8TK3Pb+VUEjvUxERGT0ykjwUZSWzsZcZYmt3HmFGfip5ab5+jzUxM5k5hems2nQ43s2Uca6iqo6ykpyuiSPdnVGcjTHhx8jYp0CsH91Dqp5+IIZyTHPcTLHErSEW2VAeJiIiIjIkS6fnctN5M3igYg9PvXUg0c2RODvU1M4n7nyVAw3t3HvdYt41dwL3rVzMpQuLuOWZLfzHn9/AHwwluplykguFLE+9dYAP3/4yV9+1ll1HWvnWB+byofmT+NHTW7ju3gpqWzoT3UwREZEucyems6n6xBliwZClclcdi6flxnys5aUFVFTV0tTuj2cTZRyrbelk26Fmynoolwjh0LZ0QjqVu2pHuGUyHIYUiBljPm6MedsYEzLGlHXbf6Ux5vVul5AxZkHkvheMMZu73VcQ2e8zxjxojNlmjFljjCkZStvixeMKd1E8w6rjZ2QdX0JxpEWDOZ3QKiIiMroYYy6KjJu2GWO+3sP9o3L8dLL7t3fP5rSiTL7+yBsc7GVxcBl7Djd1cMWv11Dd0M4915Z3LezudTv8eMV8vviuWTxUuZeV91bQqA9gJAH8wRCPvLaX9/5kNTf9fh0NbX6+f+lpvPjvy/nUOdP5yWUL+O5H5vHK9iN84Gf/ZN0uneUsIiKjw9yJGeyoaaHdHzxm/6YDjTS1B2JaPyzq/NJ8AiGrdX0lZpVd64f1/j5bVJzN+t31BDXTfswb6gyxt4BLgdXdd1pr/2CtXWCtXQBcDey01r7e7SFXRu+31kaLul4P1FlrZwK3Aj8YYtviwj0M62sdDcA45thetyturzGw9oSvQ0rERERERg1jjAu4HXgfcArwCWPMKcc9bFSOn052XrfDTy5fQIc/xFce2qDyZONAOAx7lX11bdxzbTlLph97lrIxhi+/ZzY//NjpvLL9CCvueIX99W0xH99aS3VDm/7BlkFp9wf53au7OP9HL/Dlhzbgdgw/+8RCnvvyeVy+eCq+yP+ZxhiuWlrMnz9zFm6X4bJfvcJdL+1UqU8REUm4OYUZBEOWbYeaj9k/kPXDos4oziY9yc0Lm1U2UWJTuasOr8vhtKLMXh9TXpJDc0eATb2sdSdjh3soT7bWboSjM4x68QnggRgO92HgO5Hth4HbjDHGJnh07nbFPxCLBmHRfrvmrBImZydz8fyiuL3GQNxx1SJ+89JOCtKTEvL6IiIi0qPFwDZr7Q4AY8wDhMdL3RenGpXjJ4EZ+Wl8+0On8I1H3uTul3fyqXOmJ7pJMkg1zeEwbG9dG/dcd2IY1t2KsilMykzmM79fxyW/eJm7ry3n1Ek9/2Pd3BHg5W01vLD5MKu3HGZffRtzCtP5+vvmcN7s/P7+x5KTVHNHgG2Hmtl6sCl8faiZDXvqOdLSycKpWfzXxadywZyCPt8/p03O5G+fP4evPryB//nbO1TsrOWHHz+djCTPCH4l8dfuD+IPhkjzuQf982Otpbalk+qGdlo7g+SkeslL85KR5InbEgoiInKiORPTAdhY3ci8bqHE2p21FGUlU5SVHPOxPC6Hc2fls2rzIay1GlNJvyqqapk/JZMkT++TVRYVh8sprttV1+v4XsaGIQViMbqM8Ic13d1jjAkCfwa+G/nQpgjYA2CtDRhjGoBcIKHzW91OOL0alhlikeul03NZ2sc/1sNt4dRsbr+i5xqpIiIikjBdY6OIvcCS3h4zmsZPEnZ5+RRWbTrED5/azFkz8jhlUkaimyQDFA3D9tS1cs+1i2Masy+blcefPnMmK++pYMUdr3DblWdwfmkB1lq2HGzmhc2HeGHzYSp31eIPWtJ8bs6emcsVS6byYMUerr2ngmUz8/jG++fon+1uOgJBGtsCNLT5aWz309jmp7UzSFtnkDZ/kHb/0e3utzuDIbwuB5/bhdft4HM7+DwOXpcLnyd82+t2sDZccrAzEL74gyE6gke3w9eWQMgSDIUIBC0hG71tCQQj16EQOaleSgvTmT0hnTmFGUzLS8Xrjr04SyAYorqhnb11bVQdaWHrwWa2HgoHYNUNR8uwel0O0/NTWTYrj8vLp7J0ek7MH/plpni48+pF/OafO/n+U5v40M9f4vYrzjjmQ8hYvy91LX6OtHR0Xde2dFLX0kl9mx9rwxVJHMfgGIMrcu0YurZdjsHtMngcB7fL4HY5eJzwtTtyn9sxNLYFONLSSW1LB7Ut/sh1J0cir9fSGS6z5XU75Kf5yEvzkpfmC1/Sw9v56T5yUr00tgU40NBGdWM7BxraqW4IXx9obKczcOI6gC7HkJPqJTc1fJzcNC+5qeHrpdNzuz4kExGRwSnJTSXJ47DpQFPXPmsta3fWct7s/AEfb3lpPk+8Wc3G6iaNwaVPbZ1B3tzbwA3n9n0C4+TsZCZk+KisquOTZ5aMTONkWPQbiBljngUKe7jrm9bav/bz3CVAq7X2rW67r7TW7jPGpBMOxK4GfjuANmOMuRG4EWDq1KkDeeqADc8MscSuGSYiIiInl5EcO8lRxhi+/9HTuegnq/nSA+t5/AvL+jzrUEaXI80dXPnrNeyubeXua8s5c0bsJ7DNKczg0c+dzXX3VPCp+yq5aF4h63fVsT8SZswpTGflsmksn13AouLsrrDkU+dM4w+v7uZnz2/lgz9/iUsWFvHV95YyaQBnRUN4FpG1llSve0CzWkIhS0Obn5rmDg43dXC4uYMjzZ20+YPhoCgYwh+9DoboiIREnYEgwZANBxuOg8sxXRd3t22XY7AWgiFL0FqCkYApGiyFIoFSZyBEY3uAxjZ/VwDW7j8xpOiJ2zEke1wkeV0ke1x4XAZ/0NIRCH8NHZHAKxBDeUqv28HncvC4HbwuB487HNr09PVFv26v283u2lZe2Hy46zXcjmF6fiqlhRmUTkijtDCDqTkp1DR3sK+ujb11reyta2NvfRv76to40Nh+TPnMZI+LmQVpnDk9l5kT0phVkM7MgjSmZCfjdg1+FQRjDDecO52FU7P4/B/Xc+kv/8W3PjCXUydlUN/qD1/a/DS0hsOt7rdrWzupa/HT3BHo5diQmezBMYZg5HscinzfQ5au7cHMZ/a5HXJTveSkeclJ9TEtL5WcSDjldgxHWjqpibx/9ze088a+BmpbOnssSep1OUzI9DExI5kFU7KYmJlEYWYSEzOTSPW5w4FbcydHWsI/CzWR7d27W6lt6aS5I8BX3ztbgZiIyBC5HEPphHQ2Vh8tR7f9cAtHWjq71m0diPNKwyHaqs2HFIhJn17fU08gZCkv6ftvuTGGspKcrvXGZOzqNxCz1r57CMe/HLj/uOPti1w3GWP+SLgc0G+BfcAUYK8xxg1kAkd6adOdwJ0AZWVlw1oSKDpDzB3H8Cr6T6lm7IqIiEgfomOjqMmRfT09ps/x00iOneRYOalefvTx+Xzy7rV87+8b+a8Pz0t0kyQGNc0dXPWbNeyqbeHua8o5a0begI8xISOJh246ky8/+Dovba3hzOm5fPFd+ZxXms/EzJ4DLp/bxcpl0/joosn84oVt3PNyFU+8Uc3KZdP4zPIZPZa0C4UsO2qaWberruuy/XBL1/2pXhdpSW5SfW7SIpdUn5v0SFm5muaOrsuR5s4+gyKvy8HjMnjdDh5X+OKLbLscc+yMqVCIUAgCoVDkdjgAM5GZQS7HweVwQoDmMgaP25CR5GFmQRoZSR4yUzxkJLnJTPaQEb0keUjzuSPhlxO+9rjwxBgQBYLhYC8akhno+rq87vDMpKGUWOoMhNhR08zmA01sPtDEloNNrN9dx+Mb9p/wWMdAYUYSk7NTWDwth8nZyUzOTqYoK4Xi3BSKspKHtVxfWUkOT3xxGTc/+Drf/uvbJ9wfDbeykj1kpnjJSvFSkpfaNWMqO3qd4iU3LXydleKN6QRQa23X+8MfDM+880dm4AWj+yIz8NKT3OSkeknxugb8vQmFLHWtRwOtjCQPEzOTyEn1Dun73O4Pai1uEZE4mVOYwdPvHOgqcxhdP2wwgVhBehKnFWXywuZDfO78mfFuqowjlVW1GAOLpvb/PisrzuaJN6rZX9824BPWZPQYtpKJxhgHWAGc022fG8iy1tYYYzzAB4FnI3c/BlwDvAJ8DHh+NKx/MSwzxIxmiImIiEi/KoBZxphphIOvy4ErjnvMqBw/ybHOnZ3P9cumcddLO1leWsD5cwpG9PWttdzx4g7qWzs5Z1Y+ZSXZmqnWg6Z2P89uPMgTbxxg9dbDGODua8s5a+bAw7CoNJ+bOz9ZNuD1KzKTPXzjfXO5emkxtzy9hV++sJ0HK/bwxQtmcsnCyby9vyEcfu2u47VddTS2h2fpZKd4WFSczSULi/C5XTR3BGjpCNDc7dLSEWBPbSstnQGCQUteuo8JGUmcOimjq7xcfnr0OlwWLtXnxuMaWkA02rhdDm6XQ4p3eI7vdTvMKcxgTuGxZ6U3dwTYerCJ3bWt5Kf7mJKdQmFmUsxB3nDJTfNx73WLeWlbuOJuVrKHrBQPWcle0pMGNtNwIIyJlER0May/lxzHkJvmIzfNB6TH7bj6XSoiEj9zJ6bzYOUeDjd1UJCRREVVLXlp4ZnAg3F+aT63rdpGQ6ufzJSxvU6mDJ+1VbWUTkiP6T1SVhwOzSp31XGxArExa0iBmDHmEuDnQD7whDHmdWvthZG7zwX2RBeCj/AB/4iEYS7CYdivI/fdBfzOGLMNqCX8oU/CeaJriMXxn7/j1xATEREROV5kTbDPA/8gPG6621r7tjHmv4FKa+1jjNLxk5zoaxeW8vK2Gr728Aae/NK55Kf7Ruy1b1+1jR89vQXHwK9W7yDJ47B0ei7nzsrn3Nn5zMhPHVdBx0A0tvt59p2D/P3NalZvqaEzGKIwI4krl0zlsvIpJ4QZgzXY/p2cncItly1g5bJpfO/JjXzn8Xf4zuPvRI4JswrS+MDpEzljajaLirOZlnfyfi/HijSfm4VTs1k4dfSV2HM5ZlDrtIiIiMTDnInhcdc71Y0UZCSxdmctS6bFvj7m8ZbPKeBnz29j9dbDfGj+pHg2VcaJQDDEa7vquOSMopgeP3diOileF5VVtVys99SYNaRAzFr7KPBoL/e9ACw9bl8LsKiXx7cDHx9Ke4aDKzpDzBW/fywLMnwYw4h+ECIiIiJjj7X278Dfj9v37W7bo3L8JCdK8rj42ScW8qGfv8S/P7yBu68tH5Hg4qHKPfzo6S1csrCI735kHmt2HuHFzYdZvbWG/94cDlaKspI5d3Y+583O46yZeT2W5RtPegrBJmYmcdXSYj5weiELp2QPa3m6wZhXlMnvr1/Ci1sO8+beBk6fksWCKVlkJo/v75WIiIicPOZGTkTadKCJmQVp7Ktv44Zzpg36ePMnZ5Gd4uF3r+5i7sQMZhakxaupMk5sOtBES2eQ8pLYynK6XQ4Lp2ZRWVU3zC2T4TRsJRPHC48T/9lcsyeks/4/30PWcNXnEBEREZFRZ/aEdL7xvjl85/F3+P2ru7j6zJJhfb1Vmw7xjUfe5JxZefzgo6fjdTtcMGcCF8yZAMCe2lZe3HKY1VsO8/iG/dy/djfJHhcP3LiU+VOyhrVtA7Gvvo3KqlrOnZVPdurgx88tHQHueHE7d67eQUcgxKTMJK4+s5j3nzaRhVOyRl0IdjxjDMtLC1heOrIlN0VERERGQmaKh0mZSWyqbqQgMolg8bTcQR/P5Rg+s3wGP3xqM+++5UUWT8vhisVTuWheoUreCgAVVeF16mINxAAWFedw2/NbaWr3kz7OTyQcrxSI9cMdqeUe7/W+FIaJiIiInHyuOauEVZsP890nNjIjP21I61P15fU99Xz2D68xd2I6v7xqEV73iesTTclJ4aqlxVy1tBh/MMT63fXc/MB6/u3B13nii+eQ7E3cBwWHmzp48q1qHnt9P5W7wmdgpvncrDy7hOvPmT6gmVGhkOXR9fv44T82cbCxgw8vmMQ1Z5WwYPLoD8FERERETiZzJmawsbqJJI+LjCQ3pYVDW/fxxnNncMnCyTy8bi8PVOzm5gdfJ+txDx89YzKfWDxVs8ZOcpVVdRRlJTNpAOuBlZdkE7Kwfnc956rU9JiU2JV7x4BoEBbvQExERERETj7GGG69bAEluamsvK+Cf22riftr7KxpYeW9FeSle7n72nLSfP2fA+dxOSyelsOPVsxnR00L33tyY9zb1Z+GNj8PVe7h6rvWsOT/Psu3//o2zR0BvnZhKfffsJRzZ+fxs+e3cc4Pnufnz22luSPQ7zHX7arlkl+8zFf+tIHCzGQe+exZ/PTyhZwxdfSVRRQRERE52c2dmM72w828vL2G8pKcuHwem5/u4zPLZ7DqK8v5w6eWcPbMPH77ShXvvuVFVvzqFf6yfh/t/uDQGy9jirWWiqpayksGtq7rwqnZOIauk/Zk7NEMsX54omuIOcoORURERGToclK9/OGGJVz56zWsvK+Cu64p5+w4zRQ73NTBJ+9eA8BvVy6hID1pQM8/a0Ye1y+bxl0v7eRdcydw3jCf9djWGeTZjQd5bMN+Xtx8mM5giKk5KXx2+UwuXjCJ2ROOnhV85oxc3t7fwK3PbOHHz2zh7pd38unzZvDJM4tJ8R77b83++ja+/+QmHtuwnwkZPm5ZMZ+PLChSCCYiIiIyis0pzCAQsuypbeOqJcVxPbbjGM6emcfZM/Ooae7g4XV7uX9teNZY9uMevnfp6Vw0rzCurymj1+7aVg41dVA2gHKJEK5aMacwg8pIuUUZexSI9cMdCcLc+udZREREROIkL83HH29YwhW/XsPKeyu4+9qhh2LNHQGuu3ctNU2d3H/jUqblpQ7qOF+7sJTVWw7ztT9t4B83nzukdbv68vTbB/j2X9/mQGM7EzJ8XH1mMR+aP4n5kzMxvazfe+qkTH5zTTmv76nnlme28P0nN/Gbf+7kM8tncOWSqVgLd7y4nV+t3o618IULZnLTeTNIjWGWnIiIiIgk1tyJR0+GWjxtYEHFQOSl+bjpvBnceM50Xt1xhB/8YzM3/X4dX37PbL5wwcxex6IyflRUhWd4DWT9sKjykmz+tG4vgWCoa7klGTv0HetHNAjT2aQiIiIiEk+5kVCsJDeVlfdW8PIQyid2BkJ85vfr2FjdxO1XLmTBlKxBHyvJ4+LWyxZQ19rJt/76FtbaQR+rJ4ea2vnsH9Zx4+/WkZXi4ffXL+FfX38X//nBU1gwJSumDyAWTMnitysX8/BNZzKrII3/+ds7nPf/VnHBj1/gp89t5d1zJ/DcV87jK+8tVRgmIiIiMkaU5Kbiczske1zMK8oc9tdzHMNZM/N48MalXLqwiFue2cLn/7ie1s7+S3PL2FZZVUtmsodZg1hHblFJDq2dQTZWNw1Dy2S4KRDrh+MYHKMZYiIiIiISf9FQbFpeOBR7aevAQzFrLV//8xv8c2sN37vkNC6YM2HI7ZpXlMnN757NE29U89iG/UM+HoTb+cDa3bz7xy/y7MZDfO3CUh7/wjKWzcob9PoQZSU53H/jUv54wxKm56UxJTuFP910JrddcQaTs1Pi0m4RERERGRlul8P8yVmcNSMXzwjOvEnyuPjxivl88/1zefKtaj72y1fYV982Yq8vI29tVS1lxYNbV7isOLzuWIXKJo5JCsRi4HY5uDRVVkRERESGQW6ajz98KhyKXX/fwEOxHzy1mUfW7+PL75nNivIpcWvXTefNYFFxNt/6y1vsH+IHAjtrWvjEr1/l64+8ydyJGTz1pXP43Pkz4/ZBx1kz8rj/xqU8dNOZgyp7IiIiIiKjw52fXMStly8Y8dc1xnDDudO569py9tS2cvHPX1LgMU4dae5gx+GWAa8fFjUpK5mirGTW7aqLc8tkJCgQi4HbMYM+a1VEREREpD/hmWJLu0Kxf2493OtjG9r8PP32Ab7z2NtceOtq7nhxO1csmcoXLpgZ1za5HMMtK+YTDFm++qcNhEIDL53oD4a4fdU2LvzJat7e38j3Lj2N+29YyvT8gZcmEREREZHxLyvFS0aSJ2Gvf35pAY9+7mwykj1c8etXebBid8LaIsOjMhJkLZ6WPehjLCrOpnJXbdzLy8vwU0H9GLgdg9ulQExEREREhk9Oqpc/3rCUK379Kp+6r5LfXFPGObPyaesMUrmrlpe3HeGV7TW8ua+BkIUkj0N5SQ4ryqdwzZnFw7L4d3FuKt/+4Cl8/ZE3ufdfVaxcNi3m527YU89//PkNNh1o4n3zCvmvi0+lICMp7m0UEREREYmnmQVp/OWzZ/P5+1/jP/78JpsONPHN98/FPYJlHGX4VOysxet2hrROXVlJNo9t2M/eujam5KhU+1iiQCwGHpeDo5KJIiIiIjLMjg/F5k/OYv2eOvxBi9sxLJyaxecvmMXZM3JZMDULn9s17G26rHwKz248yPef2sQ5s/KYNSG918f6gyGe23iQByr28OKWwxSk+/jV1Yu48NTCYW+niIiIiEi8ZKZ4uOfacr735CbuemknWw8285PLF5Cb6h2WE9Fk5FTsqmPB5KH9L1VWHC63WLmrVoHYGKNALAYux+BWyUQRERERGQHRUOxLD6ynvtXPyrOncdbMPMqKs0n1jfzw3RjD9y49nYt+spqbH3ydRz97Nl73sWfH7jjczIOVe/jzur3UNHcyIcPH58+fyQ3nTk9oyRsREZHjGWMuAn4KuIDfWGu/n+Amicgo5XY5/OcHT6G0MJ1vPfoWZd99Fo/LkJHkITPZQ3py+DojyU1GZDsz2UNhRhKTs5Mpyk6mID1JS/GMIq2dAd7e18Cnz5s+pOOUFqaT7nNTWVXHJQsnx6l1MhIUiMXA43Jw9ItLREREREZITqqX312/JNHN6JKf7uP/Xnoan/7dOn723Fa+emEp7f4gT75VzQNr97BmZy0ux3DBnAIuL5/CebPzVVJGRERGHWOMC7gdeA+wF6gwxjxmrX0nsS0TkdFsRdkUTpmYweqth2lsC9DY7qexzU9je4CGNj97a1tpbPfT0ObHHzx2TSm3Y5iYlURRVjJFWSldQVlemhe34+B2GTwuB4/Lwe2Et90ugydyX0cgRFtnkDZ/kHZ/kLbOIK3+IO2RfW3+INZCVoqH7BQPWSneyHb4uq9ZUNZa2v0h2vxBWjsDtHUG6QyGMBiMAWPAMQZDeBsMjgmfMOcPhugMhOgIBOnwh+gIhsLXgWBkfwgLXSFhVrKHrJRIkJjkGZGQ0FpLc0eAw00d1DR3UtPcwZv7GgiELGUlOUM6tssxLJiaRWVVXZxaKyNFgVgM3C7NEBMRERGRk9uFpxayomwyv3hhG9UN7TzzzgEa2wMU56bw7xeV8rEzJmuNMBERGe0WA9ustTsAjDEPAB8GFIiJSJ/mFWX2u+aUtZbWziDVDW3srWtjX33kOrL98rYaDja1Y22fh4mrZI+L7BQPGckeQpH2tR0Xpo00YyAj6WhA5hhDMGQJhCyhkCUQChEMWYLWEgyG91vA63LweZzItQvfMbfD180dAQ43d1LT1EFNcwcdgdAJr5+b6qWsOHvIX0dZcQ63PruF99zyIkFrsRaCIUvIhr+OoLWELIRCFscxeF0OXne4nR730dsel4PPHd52O+HbXne3oNQVfqyn62K6Ktq5HCdybXB322+MifRluD8DQUswZPGHLMFgKLI/3Nbuens/dPiDdESCzq4QNLodCIehIWvDX587+vW4ur7G6NfndTlcvGASs/sowz/cFIjFYEJ6EgXpvkQ3Q0REREQkob79oVN5dUctj7+xn/fNK+Sy8iksnZaragoiIjJWFAF7ut3eC4yeKdkiMqYZY0j1uZlZkM7Mgp4/8O8MhKhuaKOu1U8gGMIfDAcW/uh2121LMBTC63ZI9rhI9rrD1x4XyV6HJI+LlMg+i6W+1U9daycNrX7qWv3Ut3VS3+qnvrUzfLvVj8dlIs8PHyfFGz2uEz6W14UnUuXB2nAIZS2EurbDaUnI2kiI4+oKOnzu8O2ubY8DFhrbw6/d0Ba+rm8Lbze0dnZth2x4Jp1jIiGPy+CKbkcuxkBHINQ1+yy8HaS5I9C1rzMQIsXrIj/dx4y8VPLSfeSleclL8x29pHvJSfHGpZrFpWcUse1wM8FQCMeE2x9tqyty23HCs+pC1tIZsHQGw+32By2dkTY3+QMcCYToDIa63hPh90N4uzOynYjwsjtf5Hub5HHh8xz9/ke/925j6AyEaO4I0OEPRb7Wo9+r6O3TJmcqEBvt7r6uXDPEREREROSkl+Zz8/gXlgHh8iciIiLjkTHmRuBGgKlTpya4NSIynnjdDsW5qRTnxve4KV43k7KS43vQOBjPFSSm5KTw808sHLHXC4bCIVp0Bl0gZI9eB+0J+6NV76KzyKIzyDyOgytyn2NOzDx62IXX5WB6umMQvB5IfQAACOtJREFUbIKTPQViMUhLwOLlIiIiIiKjkYIwEREZw/YBU7rdnhzZdwxr7Z3AnQBlZWUJPidfREQkvG5ZstcF9L4u3FgQr2BtsLTStYiIiIiIiIiInAwqgFnGmGnGGC9wOfBYgtskIiIiI0RTn0REREREREREZNyz1gaMMZ8H/kH4FPu7rbVvJ7hZIiIiMkIUiImIiIiIiIiIyEnBWvt34O+JboeIiIiMPJVMFBERERERERERERERkXFNgZiIiIiIiIiIiIiIiIiMawrEREREREREREREREREZFzTGmIiIiIio4wx5v8BHwI6ge3Addba+h4eVwU0AUEgYK0tG8l2ioiIiIiIiIiMFZohJiIiIjL6PAPMs9aeDmwBvtHHY8+31i5QGCYiIiIiIiIi0jsFYiIiIiKjjLX2aWttIHLzVWByItsjIiIiIiIiIjLWKRATERERGd1WAk/2cp8FnjbGrDPG3DiCbRIRERERERERGVOMtTbRbRgSY8xhYNcwHDoPqBmG48qx1M/DT308MtTPw099PDKGq5+LrbX5w3DcMcsY8yxQ2MNd37TW/jXymG8CZcCltodBmzGmyFq7zxhTQLjM4hestat7eNyNQDQwKwU2x+nL6E4/o4mjvk8s9X/iqO8TR30//DR2GiX0udO4pL5PHPV9Yqn/E0d9P/xiGjuN+UBsuBhjKrUWx/BTPw8/9fHIUD8PP/XxyFA/jx7GmGuBTwPvsta2xvD47wDN1tofDXPTent9vXcSRH2fWOr/xFHfJ476XmTo9HOUOOr7xFHfJ5b6P3HU96OHSiaKiIiIjDLGmIuAfwcu7i0MM8akGmPSo9vAe4G3Rq6VIiIiIiIiIiJjhwIxERERkdHnNiAdeMYY87ox5g4AY8wkY8zfI4+ZALxkjNkArAWesNY+lZjmioiIiIiIiIiMbu5EN2AUuzPRDThJqJ+Hn/p4ZKifh5/6eGSon0cBa+3MXvbvB94f2d4BzB/JdvVD753EUd8nlvo/cdT3iaO+Fxk6/Rwljvo+cdT3iaX+Txz1/SihNcRERERERERERERERERkXFPJRBERERERERERERERERnXFIj1wBhzkTFmszFmmzHm64luz1hmjLnbGHPIGPNWt305xphnjDFbI9fZkf3GGPOzSL+/YYw5I3EtHzuMMVOMMauMMe8YY942xnwpsl/9HCfGmCRjzFpjzIZIH/9XZP80Y8yaSF8+aIzxRvb7Ire3Re4vSWT7xxJjjMsYs94Y87fIbfVxnBljqowxb0bWpaqM7NPvCxkSjZ1GzkDGVhJfAx1zSfwMdCwm8RfrGE1E+qdx08jS2ClxNHZKHI2dEk9jp9FLgdhxjDEu4HbgfcApwCeMMacktlVj2r3ARcft+zrwnLV2FvBc5DaE+3xW5HIj8MsRauNYFwC+Yq09BVgKfC7ynlU/x08HcIG1dj6wALjIGLMU+AFwa2Stnzrg+sjjrwfqIvtvjTxOYvMlYGO32+rj4XG+tXaBtbYsclu/L2TQNHYacfcS+9hK4mugYy6Jn4GOxST+Yh2jiUgfNG5KiHvR2ClRNHZKHI2dEk9jp1FKgdiJFgPbrLU7rLWdwAPAhxPcpjHLWrsaqD1u94eB+yLb9wEf6bb/tzbsVSDLGDNxZFo6dllrq621r0W2mwj/si1C/Rw3kb5qjtz0RC4WuAB4OLL/+D6O9v3DwLuMMWaEmjtmGWMmAx8AfhO5bVAfjxT9vpCh0NhpBA1wbCVxNIgxl8TJIMZiEkcDHKOJSN80bhphGjsljsZOiaOxU2Jp7DS6KRA7URGwp9vtvZF9Ej8TrLXVke0DwITItvp+iEy4bNxCYA3q57iKTHV+HTgEPANsB+qttYHIQ7r3Y1cfR+5vAHJHtsVj0k+AfwdCkdu5qI+HgwWeNsasM8bcGNmn3xcyFHqfJF5vP8MyTGIcc0kcDXAsJvE1kDGaiPRN46bRQX+7R5jGTiNPY6eE0thpFFMgJgllrbWEP5yVITLGpAF/Bm621jZ2v0/9PHTW2qC1dgEwmfBZfXMS3KRxxRjzQeCQtXZdottyElhmrT2DcJmWzxljzu1+p35fiIxt+hkefhpzJYbGYomhMZqIjHf62z38NHZKDI2dEkNjp9FPgdiJ9gFTut2eHNkn8XMwWnIrcn0osl99P0jGGA/hwcUfrLWPRHarn4eBtbYeWAWcSbh8nDtyV/d+7OrjyP2ZwJERbupYczZwsTGminDZkAuAn6I+jjtr7b7I9SHgUcIDY/2+kKHQ+yTxevsZljgb4JhLhkGMYzGJn4GO0USkbxo3jQ762z1CNHZKPI2dRpzGTqOcArETVQCzjDHTjDFe4HLgsQS3abx5DLgmsn0N8Ndu+z9pwpYCDd2mUEsvInVo7wI2Wmtv6XaX+jlOjDH5xpisyHYy8B7Cta9XAR+LPOz4Po72/ceA5yNnPUkvrLXfsNZOttaWEP69+7y19krUx3FljEk1xqRHt4H3Am+h3xcyNBo7JV5vP8MSR4MYc0mcDGIsJnEyiDGaiPRN46bRQX+7R4DGTomjsVPiaOw0+hl9fngiY8z7Cdf6dAF3W2v/N8FNGrOMMfcDy4E84CDw/wF/AR4CpgK7gBXW2trIH8rbgIuAVuA6a21lIto9lhhjlgH/BN7kaG3a/0O4LrP6OQ6MMacTXvDSRfhEgoestf9tjJlO+GyPHGA9cJW1tsMYkwT8jnB97FrgcmvtjsS0fuwxxiwHvmqt/aD6OL4i/flo5KYb+KO19n+NMbno94UMgcZOI2cgY6tEtXG8GuiYKyGNHKcGOhZLXEvHt1jGaIlsn8hYoXHTyNLYKXE0dkocjZ1GB42dRicFYiIiIiIiIiIiIiIiIjKuqWSiiIiIiIiIiIiIiIiIjGsKxERERERERERERERERGRcUyAmIiIiIiIiIiIiIiIi45oCMRERERERERERERERERnXFIiJiIiIiIiIiIiIiIjIuKZATERERERERERERERERMY1BWIiIiIiIiIiIiIiIiIyrikQExERERERERERERERkXHt/wczfsmkBRrVuAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 2160x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  [[-293.89303003]]\n"
     ]
    }
   ],
   "source": [
    "# test\n",
    "if IN_COLAB:\n",
    "    agent.env = gym.wrappers.Monitor(agent.env, \"videos\", force=True)\n",
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgLJUUGDMBUBHLRBLL\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderLJUUGDMBUBHLRBLL\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animLJUUGDMBUBHLRBLL.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animLJUUGDMBUBHLRBLL.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animLJUUGDMBUBHLRBLL.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animLJUUGDMBUBHLRBLL.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animLJUUGDMBUBHLRBLL.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animLJUUGDMBUBHLRBLL.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animLJUUGDMBUBHLRBLL.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animLJUUGDMBUBHLRBLL.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animLJUUGDMBUBHLRBLL.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animLJUUGDMBUBHLRBLL.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectLJUUGDMBUBHLRBLL\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" > Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" checked> Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgLJUUGDMBUBHLRBLL\";\n",
       "    var slider_id = \"_anim_sliderLJUUGDMBUBHLRBLL\";\n",
       "    var loop_select_id = \"_anim_loop_selectLJUUGDMBUBHLRBLL\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "  frames[36] = \"\"\n",
       "  frames[37] = \"\"\n",
       "  frames[38] = \"\"\n",
       "  frames[39] = \"\"\n",
       "  frames[40] = \"\"\n",
       "  frames[41] = \"\"\n",
       "  frames[42] = \"\"\n",
       "  frames[43] = \"\"\n",
       "  frames[44] = \"\"\n",
       "  frames[45] = \"\"\n",
       "  frames[46] = \"\"\n",
       "  frames[47] = \"\"\n",
       "  frames[48] = \"\"\n",
       "  frames[49] = \"\"\n",
       "  frames[50] = \"\"\n",
       "  frames[51] = \"\"\n",
       "  frames[52] = \"\"\n",
       "  frames[53] = \"\"\n",
       "  frames[54] = \"\"\n",
       "  frames[55] = \"\"\n",
       "  frames[56] = \"\"\n",
       "  frames[57] = \"\"\n",
       "  frames[58] = \"\"\n",
       "  frames[59] = \"\"\n",
       "  frames[60] = \"\"\n",
       "  frames[61] = \"\"\n",
       "  frames[62] = \"\"\n",
       "  frames[63] = \"\"\n",
       "  frames[64] = \"\"\n",
       "  frames[65] = \"\"\n",
       "  frames[66] = \"\"\n",
       "  frames[67] = \"\"\n",
       "  frames[68] = \"\"\n",
       "  frames[69] = \"\"\n",
       "  frames[70] = \"\"\n",
       "  frames[71] = \"\"\n",
       "  frames[72] = \"\"\n",
       "  frames[73] = \"\"\n",
       "  frames[74] = \"\"\n",
       "  frames[75] = \"\"\n",
       "  frames[76] = \"\"\n",
       "  frames[77] = \"\"\n",
       "  frames[78] = \"\"\n",
       "  frames[79] = \"\"\n",
       "  frames[80] = \"\"\n",
       "  frames[81] = \"\"\n",
       "  frames[82] = \"\"\n",
       "  frames[83] = \"\"\n",
       "  frames[84] = \"\"\n",
       "  frames[85] = \"\"\n",
       "  frames[86] = \"\"\n",
       "  frames[87] = \"\"\n",
       "  frames[88] = \"\"\n",
       "  frames[89] = \"\"\n",
       "  frames[90] = \"\"\n",
       "  frames[91] = \"\"\n",
       "  frames[92] = \"\"\n",
       "  frames[93] = \"\"\n",
       "  frames[94] = \"\"\n",
       "  frames[95] = \"\"\n",
       "  frames[96] = \"\"\n",
       "  frames[97] = \"\"\n",
       "  frames[98] = \"\"\n",
       "  frames[99] = \"\"\n",
       "  frames[100] = \"\"\n",
       "  frames[101] = \"\"\n",
       "  frames[102] = \"\"\n",
       "  frames[103] = \"\"\n",
       "  frames[104] = \"\"\n",
       "  frames[105] = \"\"\n",
       "  frames[106] = \"\"\n",
       "  frames[107] = \"\"\n",
       "  frames[108] = \"\"\n",
       "  frames[109] = \"\"\n",
       "  frames[110] = \"\"\n",
       "  frames[111] = \"\"\n",
       "  frames[112] = \"\"\n",
       "  frames[113] = \"\"\n",
       "  frames[114] = \"\"\n",
       "  frames[115] = \"\"\n",
       "  frames[116] = \"\"\n",
       "  frames[117] = \"\"\n",
       "  frames[118] = \"\"\n",
       "  frames[119] = \"\"\n",
       "  frames[120] = \"\"\n",
       "  frames[121] = \"\"\n",
       "  frames[122] = \"\"\n",
       "  frames[123] = \"\"\n",
       "  frames[124] = \"\"\n",
       "  frames[125] = \"\"\n",
       "  frames[126] = \"\"\n",
       "  frames[127] = \"\"\n",
       "  frames[128] = \"\"\n",
       "  frames[129] = \"\"\n",
       "  frames[130] = \"\"\n",
       "  frames[131] = \"\"\n",
       "  frames[132] = \"\"\n",
       "  frames[133] = \"\"\n",
       "  frames[134] = \"\"\n",
       "  frames[135] = \"\"\n",
       "  frames[136] = \"\"\n",
       "  frames[137] = \"\"\n",
       "  frames[138] = \"\"\n",
       "  frames[139] = \"\"\n",
       "  frames[140] = \"\"\n",
       "  frames[141] = \"\"\n",
       "  frames[142] = \"\"\n",
       "  frames[143] = \"\"\n",
       "  frames[144] = \"\"\n",
       "  frames[145] = \"\"\n",
       "  frames[146] = \"\"\n",
       "  frames[147] = \"\"\n",
       "  frames[148] = \"\"\n",
       "  frames[149] = \"\"\n",
       "  frames[150] = \"\"\n",
       "  frames[151] = \"\"\n",
       "  frames[152] = \"\"\n",
       "  frames[153] = \"\"\n",
       "  frames[154] = \"\"\n",
       "  frames[155] = \"\"\n",
       "  frames[156] = \"\"\n",
       "  frames[157] = \"\"\n",
       "  frames[158] = \"\"\n",
       "  frames[159] = \"\"\n",
       "  frames[160] = \"\"\n",
       "  frames[161] = \"\"\n",
       "  frames[162] = \"\"\n",
       "  frames[163] = \"\"\n",
       "  frames[164] = \"\"\n",
       "  frames[165] = \"\"\n",
       "  frames[166] = \"\"\n",
       "  frames[167] = \"\"\n",
       "  frames[168] = \"\"\n",
       "  frames[169] = \"\"\n",
       "  frames[170] = \"\"\n",
       "  frames[171] = \"\"\n",
       "  frames[172] = \"\"\n",
       "  frames[173] = \"\"\n",
       "  frames[174] = \"\"\n",
       "  frames[175] = \"\"\n",
       "  frames[176] = \"\"\n",
       "  frames[177] = \"\"\n",
       "  frames[178] = \"\"\n",
       "  frames[179] = \"\"\n",
       "  frames[180] = \"\"\n",
       "  frames[181] = \"\"\n",
       "  frames[182] = \"\"\n",
       "  frames[183] = \"\"\n",
       "  frames[184] = \"\"\n",
       "  frames[185] = \"\"\n",
       "  frames[186] = \"\"\n",
       "  frames[187] = \"\"\n",
       "  frames[188] = \"\"\n",
       "  frames[189] = \"\"\n",
       "  frames[190] = \"\"\n",
       "  frames[191] = \"\"\n",
       "  frames[192] = \"\"\n",
       "  frames[193] = \"\"\n",
       "  frames[194] = \"\"\n",
       "  frames[195] = \"\"\n",
       "  frames[196] = \"\"\n",
       "  frames[197] = \"\"\n",
       "  frames[198] = \"\"\n",
       "  frames[199] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animLJUUGDMBUBHLRBLL = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if IN_COLAB:  # for colab\n",
    "    import base64\n",
    "    import glob\n",
    "    import io\n",
    "    import os\n",
    "\n",
    "    from IPython.display import HTML, display\n",
    "\n",
    "    def ipython_show_video(path: str) -> None:\n",
    "        \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "        if not os.path.isfile(path):\n",
    "            raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "        video = io.open(path, \"r+b\").read()\n",
    "        encoded = base64.b64encode(video)\n",
    "\n",
    "        display(HTML(\n",
    "            data=\"\"\"\n",
    "            <video alt=\"test\" controls>\n",
    "            <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "            </video>\n",
    "            \"\"\".format(encoded.decode(\"ascii\"))\n",
    "        ))\n",
    "\n",
    "    list_of_files = glob.glob(\"videos/*.mp4\")\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    print(latest_file)\n",
    "    ipython_show_video(latest_file)\n",
    "\n",
    "else:  # for jupyter\n",
    "    from matplotlib import animation\n",
    "    from JSAnimation.IPython_display import display_animation\n",
    "    from IPython.display import display\n",
    "\n",
    "\n",
    "    def display_frames_as_gif(frames):\n",
    "        \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
    "        patch = plt.imshow(frames[0])\n",
    "        plt.axis('off')\n",
    "\n",
    "        def animate(i):\n",
    "            patch.set_data(frames[i])\n",
    "\n",
    "        anim = animation.FuncAnimation(\n",
    "            plt.gcf(), animate, frames = len(frames), interval=50\n",
    "        )\n",
    "        display(display_animation(anim, default_mode='loop'))\n",
    "\n",
    "\n",
    "    # display \n",
    "    display_frames_as_gif(frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pgayn",
   "language": "python",
   "name": "pgayn"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
